diff --git a/doc/.gitignore b/doc/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..7c5f0a3725c4e27a34fd5a500aaae8dc224f880f
--- /dev/null
+++ b/doc/.gitignore
@@ -0,0 +1,2 @@
+build
+source
diff --git a/doc/build/.buildinfo b/doc/build/.buildinfo
deleted file mode 100644
index e317b25f7a52f7ade3d35d88c07196f4ab481f91..0000000000000000000000000000000000000000
--- a/doc/build/.buildinfo
+++ /dev/null
@@ -1,4 +0,0 @@
-# Sphinx build info version 1
-# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
-config: 9798cb7c323d649f30ace31514263ca4
-tags: fbb0d17656682115ca4d033fb2f83ba1
diff --git a/doc/build/.doctrees/base/base.doctree b/doc/build/.doctrees/base/base.doctree
deleted file mode 100644
index 309ef77fd49aefd3546d5d08063598e8f79030e7..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/base/base.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/base/generic.doctree b/doc/build/.doctrees/base/generic.doctree
deleted file mode 100644
index d2b1a63236dfebf8803a2b5fc10934c3182594f1..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/base/generic.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/conop/conop.doctree b/doc/build/.doctrees/conop/conop.doctree
deleted file mode 100644
index b8162bb166543abb15b4b2df0ff57362367b4a7a..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/conop/conop.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/environment.pickle b/doc/build/.doctrees/environment.pickle
deleted file mode 100644
index 9d288cce0edd5f200b60bf0d8853abb292bbb185..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/environment.pickle and /dev/null differ
diff --git a/doc/build/.doctrees/external.doctree b/doc/build/.doctrees/external.doctree
deleted file mode 100644
index 624ac471b710549d3fd24c8c3b26aaab1b509180..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/external.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/geom/composite.doctree b/doc/build/.doctrees/geom/composite.doctree
deleted file mode 100644
index 7b49a6d13106effb13c351106ed1d450db4f92b1..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/geom/composite.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/geom/geom.doctree b/doc/build/.doctrees/geom/geom.doctree
deleted file mode 100644
index 1dab64c97f3082efc18382d10cc9063b245029ec..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/geom/geom.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/geom/mat.doctree b/doc/build/.doctrees/geom/mat.doctree
deleted file mode 100644
index 22fd1d47772ea2039370341176b8f7f2a0a4f0b5..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/geom/mat.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/geom/vec.doctree b/doc/build/.doctrees/geom/vec.doctree
deleted file mode 100644
index 7a7ee645acd9a1045e5cb907a0d6e79df1af00e9..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/geom/vec.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/gui/gui.doctree b/doc/build/.doctrees/gui/gui.doctree
deleted file mode 100644
index b0a7ce81135f6c05f052cfa9c2e168074c62726f..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/gui/gui.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/img/alg/alg.doctree b/doc/build/.doctrees/img/alg/alg.doctree
deleted file mode 100644
index 22154eb2561ca86d7039ae6637cb92e0be4e77ef..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/img/alg/alg.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/img/base/img.doctree b/doc/build/.doctrees/img/base/img.doctree
deleted file mode 100644
index 0020ff5e40ba9c66cb7052174a7165cd893e30cb..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/img/base/img.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/index.doctree b/doc/build/.doctrees/index.doctree
deleted file mode 100644
index 0db23e932620bdd4b1765f86a4284fff12ee91be..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/index.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/install.doctree b/doc/build/.doctrees/install.doctree
deleted file mode 100644
index 15c5d7101cf51edeb04ac19e87c6750e8356c2ec..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/install.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/intro.doctree b/doc/build/.doctrees/intro.doctree
deleted file mode 100644
index 0d1fd26f0b3037fc61d3351f5c3d294ffbde07e5..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/intro.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/io/formats.doctree b/doc/build/.doctrees/io/formats.doctree
deleted file mode 100644
index ad5c9d655fdb4c334055f2220966590d37b35784..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/io/formats.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/io/io.doctree b/doc/build/.doctrees/io/io.doctree
deleted file mode 100644
index 978dcdb010501138b5211807ee05261448d6ad34..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/io/io.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/mol/base/editors.doctree b/doc/build/.doctrees/mol/base/editors.doctree
deleted file mode 100644
index 5044f66ef8cee8c10e4da25775595afe52a3d213..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/mol/base/editors.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/mol/base/entity.doctree b/doc/build/.doctrees/mol/base/entity.doctree
deleted file mode 100644
index 112fdb30e0a84ecd6af5285ce01924f42e7729b3..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/mol/base/entity.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/mol/base/mol.doctree b/doc/build/.doctrees/mol/base/mol.doctree
deleted file mode 100644
index 5fe0f6260ffe3c2d96b044ed7b9d144938170415..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/mol/base/mol.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/mol/base/query.doctree b/doc/build/.doctrees/mol/base/query.doctree
deleted file mode 100644
index 3a187bf7c0d5038815a6810eae688a1ee91b9283..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/mol/base/query.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/newmodule.doctree b/doc/build/.doctrees/newmodule.doctree
deleted file mode 100644
index 7bed2275f5dc9c9c09b8aae259077ca10fa46e0c..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/newmodule.doctree and /dev/null differ
diff --git a/doc/build/.doctrees/seq/base/seq.doctree b/doc/build/.doctrees/seq/base/seq.doctree
deleted file mode 100644
index 36e16ef43a0650362383e208038772ea289bb6d5..0000000000000000000000000000000000000000
Binary files a/doc/build/.doctrees/seq/base/seq.doctree and /dev/null differ
diff --git a/doc/build/_images/100208_OpenStructure_UI_Colored.png b/doc/build/_images/100208_OpenStructure_UI_Colored.png
deleted file mode 100644
index 53338891b594d8dc23e2b9ea509a30c01b5dcb45..0000000000000000000000000000000000000000
Binary files a/doc/build/_images/100208_OpenStructure_UI_Colored.png and /dev/null differ
diff --git a/doc/build/_images/100208_OpenStructure_UI_Colored1.png b/doc/build/_images/100208_OpenStructure_UI_Colored1.png
deleted file mode 100644
index 53338891b594d8dc23e2b9ea509a30c01b5dcb45..0000000000000000000000000000000000000000
Binary files a/doc/build/_images/100208_OpenStructure_UI_Colored1.png and /dev/null differ
diff --git a/doc/build/_sources/base/base.txt b/doc/build/_sources/base/base.txt
deleted file mode 100644
index 8bec08e983113dffdae61f80ef509ae6fecd9abe..0000000000000000000000000000000000000000
--- a/doc/build/_sources/base/base.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-:mod:`ost.settings` - Locate Files and Retrieve Preferences
-================================================================================
-
-.. automodule:: ost.settings
- :synopsis: Helper Functions to Locate Files and Retrieve Preferences
- :members:
-
-
-
diff --git a/doc/build/_sources/base/generic.txt b/doc/build/_sources/base/generic.txt
deleted file mode 100644
index 6c2cd34cb6d0a29b75a8a8470c6b07a8f7e67d7d..0000000000000000000000000000000000000000
--- a/doc/build/_sources/base/generic.txt
+++ /dev/null
@@ -1,157 +0,0 @@
-Storing Custom Data
-================================================================================
-
-Introduction
---------------------------------------------------------------------------------
-
-It is often very convenient to store any arbitrary data inside an Entity. A few examples are:
-
- * calculated properties of atoms
- * sequence conservation of a residue
- * interaction energy of a substructure with its surrounding
- * fit of a fragment inside an electron density map
-
-In OpenStructure this is supported by the use of generic properties. Most
-building blocks are derived from :class:`GenericPropertyContainer`, meaning that
-arbitrary key-value pairs can be stored in them. In essence, the following
-classes support generic properties:
-
- * :class:`~mol.EntityHandle` and :class:`~mol.EntityView`
- * :class:`~mol.ChainHandle` and :class:`~mol.ChainView`
- * :class:`~ResidueHandle` and :class:`~mol.ResidueView`
- * :class:`~mol.AtomHandle` and :class:`~mol.AtomView`
- * :class:`~mol.BondHandle`
- * :class:`~seq.SequenceHandle` and :class:`~seq.AlignmentHandle`
-
-The view variants will reflect the generic properties of the handle variants.
-
-A generic property key is always a string, and a value can be one of string, float, int or bool. For each of these data types, methods to retrieve and store values are available both in Python and C++.
-
-Storing and Accessing Data
---------------------------------------------------------------------------------
-
-All OpenStructure building blocks that are :class:`GenericPropContainers`, have
-four different methods to store generic data, depending on the data type (i.e.
-string, float, int or bool).
-
-To store a float value with the key 'myfloatprop' in all atoms of an entity:
-
-.. code-block:: python
-
- import math
- for atom in entity.GetAtomList():
- val=5*math.sin(0.4*atom.GetPos().GetX())
- atom.SetFloatProp("myfloatprop", val)
-
-If a GenericProp at a given level (i.e. atom, bond, residue, chain or entity)
-already exists, it will be overwritten. To check if it exists, use:
-
-.. code-block:: python
-
- exists=atom.HasProp("myfloatprop")
- print exists
-
-To access the value of a generic property, we first check if the property exists
-and then access it, using the method suitable for the data type of the property.
-For the previously set property "myfloatprop" of the data type real, at the atom
-level:
-
-.. code-block:: python
-
- for atom in entity.GetAtomList():
- if atom.HasProp("myfloatprop"):
- print atom.GetFloatProp("myfloatprop")
-
-When trying to access a property that has not been set, or one that has been
-set, but at a different level, an error is thrown. The same is true when trying
-to access a property of a different data type, e.g.:
-
-.. code-block:: python
-
- # all of the following lines will throw errors
- # error because the property does not exist
- print atom.GetFloatProp("unknownprop")
-
- # error because the property was set at another level
- print entity.GetFloatProp("myfloatprop")
-
- # error because the data type of the property is different
- print atom.GetStringProp("myfloatprop")
-
-
-Use of Generic Properties in Queries
---------------------------------------------------------------------------------
-
-The :doc:`../mol/base/query` can also be used for numeric generic properties (i.e. bool,
-int, float), but the syntax is slightly different. To access any generic
-properties, it needs to be specified that they are generic and at which level
-they are defined. Therefore, all generic properties start with a 'g', followed
-by an 'a', 'r' or 'c' for atom, residue or chain level respectively. For more
-details see :doc:`../mol/base/query`.
-
-
-API documentation
---------------------------------------------------------------------------------
-
-.. class:: GenericPropertyContainer
-
- .. method:: HasProp(key)
-
- checks existence of property. Returns true, if the the class contains a
- property with the given name, false if not.
-
- .. method:: GetPropAsString(key)
-
- Returns the string representation of a property, or the empty String if
- the property addressed by key does not exist. Note that this is not the
- same as trying to get a generic float/int/bool property as a string type;
- the latter will result in a boost:get exception. Use this method to obtain
- a representation suitable for output.
-
- .. method:: GetStringProp(key)
- GetStringProp(key, default_value)
-
- Get string property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
-
- .. method:: GetFloatProp(key)
- GetFloatProp(key, default_value)
-
- Get float property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
-
- .. method:: GetIntProp(key)
- GetIntProp(key, default_value)
-
- Get int property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
- .. method:: GetBoolProp(key)
- GetBoolProp(key, default_value)
-
- Get bool property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
- .. method:: ClearProps()
-
- Remove all generic properties
-
-
- .. method:: SetStringProp(key, value)
-
- Set string property, overriding an existing property with the same name
-
- .. method:: SetFloatProp(key, value)
-
- Set float property, overriding an existing property with the same name
-
- .. method:: SetIntProp(key, value)
-
- Set int property, overriding an existing property with the same name
-
- .. method:: SetBoolProp(key, value)
-
- Set bool property, overriding a property with the same name
-
diff --git a/doc/build/_sources/conop/conop.txt b/doc/build/_sources/conop/conop.txt
deleted file mode 100644
index a7ebe2eaa24fd6cb3c6f2990e9ba939b77644544..0000000000000000000000000000000000000000
--- a/doc/build/_sources/conop/conop.txt
+++ /dev/null
@@ -1,255 +0,0 @@
-:mod:`~ost.conop` -- Connectivity and Topology of Molecules
-================================================================================
-
-.. module:: ost.conop
- :synopsis: The conop modules implement different strategies to derive
- connectivity information of molecules.
-
-The main task of the conop module is to connect atoms with bonds. While the
-bond class is also part of the base module, the conop module deals with setting
-up the correct bonds between atoms.
-
-Motivation
---------------------------------------------------------------------------------
-Traditionally the connectivity between atoms has not been reliably described in
-a PDB file. Different programs adopted various ways of finding out if two atoms
-are connected. One way chosen is to rely on proper naming of the atoms. For
-example, the backbone atoms of the standard amino acids are named as N, CA, C
-and O and if atoms with these name appear in the same residue they are shown
-connected. Another way is to apply additional heuristics to find out if a
-peptide bond between two consecutive residues is formed. Breaks in the backbone
-are indicated, e.g., by introducing a discontinuity in the numbering of the residue.
-
-Loader heuristics are great if you are the one that implemented them but are
-problematic if you are just the user of a software that has them. As time goes
-on, these heuristics become buried in thousands of lines of code and they are
-often hard yet impossible to trace back.
-
-Different clients of the framework have different requirements. A visualisation
-software wants to read in a PDB files as is without making any changes. A
-script in an automated pipeline, however, does want to either strictly reject
-files that are incomplete or fill-in missing structural features. All these
-aspects are implemented in the conop module, separated from the loading of the
-PDB file, giving clients a fine grained control over the loading process.
-
-The Builder interface
---------------------------------------------------------------------------------
-
-The conop module defines a :class:`Builder` interface, to run connectivity
-algorithms, that is to connect the atoms with bonds and perform basic clean up
-of errorneous structures. The clients of the conop module can specify how the
-Builder should treat unknown amino acids, missing atoms and chemically
-infeasible bonds.
-
-The exact behaviour for a builder is implementation-specific. So far, two
-classes implement the Builder interface: A heuristic and a rule-based builder. The builders mainly differ in the source of their connectivity information. The
-HeuristicBuilder uses a hard-coded heuristic connectivity table for the 20
-standard amino acids as well as nucleotides.For other compounds such as ligands
-the HeuristicBuilder runs a distance-based connectivity algorithm that connects
-two atoms if they are closer than a certain threshold. The RuleBasedBuilder
-uses a connectivity library containing all molecular components present in the
-PDB files on PDB.org. The library can easily be extended with custom
-connectivity information, if required. By default the heuristic builder is used,
-however the builder may be switched by setting the !RuleBasedBuilder as the
-default. To do so, one has first to create a new instance of a RuleBasedBuilder
-and register it in the builder registry of the conop module. In Python, this can
-be achieved with
-
-.. code-block:: python
-
- from ost import conop
- compound_lib=conop.CompoundLib.Load('...')
- rbb=conop.RuleBasedBuilder(compound_lib)
- conop.Conopology.Instance().RegisterBuilder(rbb,'rbb')
- conop.Conopology.Instance().SetDefaultBuilder('rbb')
-
-All subsequent calls to :func:`io.LoadEntity` will make use of the
-RuleBasedBuilder instead of the heuristic builder. See
-:ref:`here <mmcif-convert>` for more information on how to create the necessary
-files to use the rule-based builder.
-
-
-.. class:: Builder
-
- .. method:: CompleteAtoms(residue)
-
- add any missing atoms to the residue based on its key, with coordinates set
- to zero.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: CheckResidueCompleteness(residue)
-
- verify that the given residue has all atoms it is supposed to have based on
- its key.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: IsResidueComplete(residue)
-
- Check whether the residue has all atoms it is supposed to have. Hydrogen
- atoms are not required for a residue to be complete.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: IdentifyResidue(residue)
-
- attempt to identify the residue based on its atoms, and return a suggestion
- for the proper residue key.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: ConnectAtomsOfResidue(residue)
-
- Connects atoms of residue based on residue and atom name. This method does
- not establish inter-residue bonds. To connect atoms that belong to
- different residues, use :meth:`ConnectResidueToPrev`, or
- :meth:`ConnectResidueToNext`.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: ConnectResidueToPrev(residue, prev)
-
- Connect atoms of residue to previous. The order of the parameters is
- important. In case of a polypeptide chain, the residues are thought to be
- ordered from N- to C- terminus.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
- :param prev: valid or invalid residue
- :type prev: mol.ResidueHandle
-
-
- .. method:: DoesPeptideBondExist(n, c)
-
- Check if peptide bond should be formed between the `n` and `c` atom. This
- method is called by ConnectResidueWithNext() after making sure that
- both residues participating in the peptide bond are peptide linking
- components.
-
- By default, :meth:`IsBondFeasible` is used to check whether the two atoms
- form a peptide bond.
-
- :param n: backbone nitrogen atom (IUPAC name `N`). Must be valid.
- :type n: mol.AtomHandle
- :param c: backbone C-atom (IUPAC name `C`). Must be valid.
- :type c: mol.AtomHandle
-
- .. method:: IsBondFeasible(atom_a, atom_b)
-
- Overloadable hook to check if bond between to atoms is feasible. The
- default implementation uses a distance-based check to check if the
- two atoms should be connected. The atoms are connected if they are in
- the range of 0.8 to 1.2 times their van-der-WAALS radius.
-
- :param atom_a: a valid atom
- :type atom_b: mol.AtomHandle
- :param atom_a: a valid atom
- :type atom_b: mol.AtomHandle
-
- .. method:: GuessAtomElement(atom_name, hetatm)
-
- guess element of atom based on name and hetatm flag
-
- :param atom_name: IUPAC atom name, e.g. `CA`, `CB` or `N`.
- :type atom_name: string
- :param hetatm: Whether the atom is a hetatm or not
- :type hetatm: bool
-
- .. method:: AssignBackboneTorsionsToResidue(residue)
-
- For :meth:`peptide-linking residues <mol.ResidueHandle.IsPeptideLinking>`,
- residues, assigns phi, psi and omega torsions to amino acid.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
-
-.. class:: RuleBasedBuilder
-
- The :class:`RuleBasedBuilder` implements the :class:`Builder` interface.
- Refer to its documentation for a basic description of the methods.
-
- .. method:: CheckResidueCompleteness(residue)
-
- By using the description of the chemical compound, the completeness of
- the residue is verified. The method distinguishes between required atoms
- and atoms that are optional, like `OXT` that is only present, if not
- peptide bond is formed. Whenever an unknown atom is encountered,
- :meth:`OnUnknownAtom` is invoked. Subclasses of the
- :class:`RuleBasedBuilder` may implement some additional logic to deal with
- unknown atom. Likewise, whenever a required atom is missing,
- :meth:`OnMissingAtom` is invoked. Hydrogen atoms are not considered as
- required by default.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: IdentifyResidue(residue)
-
- Looks-up the residue in the database of chemical compounds and returns
- the name of the residue or "UNK" if the residue has not been found in the
- library.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
-
- .. method:: OnUnknownAtom(atom)
-
- Invoked whenever an unkknown atom has been encountered during a residue
- completeness check.
-
- The default implementation guesses the atom properties based on the name
- and returns false, meaning that it should be treated as an unknown atom.
-
- Custom implementations of this method may delete the atom, or modify it.
-
- :param atom: the unknown atom
- :type atom: mol.AtomHandle
-
- .. method:: OnMissingAtom(atom)
-
- Invoked whenever an atom is missing. It is up to the overloaded method
- to deal with the missing atom, either by ignoring it or by inserting a
- dummy atom.
-
- :param atom: The missing atom's name
- :type atom: string
-
-Connecting atoms
---------------------------------------------------------------------------------
-
-The high level interface is exposed by the Conopoloy singleton instance:
-
-.. code-block:: python
-
- import conop
-
- cc=conop.Conopology.Instance()
-
- ent=BuildRawModel(...)
- cc.ConnectAll(cc.GetBuilder(), ent)
-
-For fine grained control, the builder interface may be used directly.
-
-
-.. _mmcif-convert:
-
-Convert MM CIF dictionary
---------------------------------------------------------------------------------
-
-The CompoundLib may be created from a MM CIF dictionary. The latest dictionary
-can be found on the `wwPDB site <http://www.wwpdb.org/ccd.html>`_.
-
-After downloading the file in MM CIF use the :program:`chemdict_tool` to convert
-the MM CIF dictionary into our internal format.
-
-.. code-block:: bash
-
- chemdict_tool create <components.cif> <compounds.chemlib>
diff --git a/doc/build/_sources/external.txt b/doc/build/_sources/external.txt
deleted file mode 100644
index 7ea3b22db79befda28b9a262e95a91cd64b26d6d..0000000000000000000000000000000000000000
--- a/doc/build/_sources/external.txt
+++ /dev/null
@@ -1,111 +0,0 @@
-Using External Programs within OpenStructure
-================================================================================
-
-Introduction
---------------------------------------------------------------------------------
-
-It is often very useful to use external programs to do a specific task. In principle, this can be done by writing out files from OpenStructure and manually running an external program, however, for convenience, this can also be done directly from within OpenStructure using Python commands.
-
-This tutorial will give you some hints how to do this for a new external program. The process basically consists of four steps:
-
- * locate the executable of the external program
- * prepare all necessary files
- * execute the external program from python
- * read in generated output
-
-
-Locating the Executable
---------------------------------------------------------------------------------
-
-There is a helper function available to locate files, and especially executables: :func:`~ost.settings.Locate`. Using this, you can obtain the full path of an executable.
-
-As an example, we would like to obtain the full path of the msms executable (a program to calculate molecular surfaces):
-
-.. code-block:: python
-
- from ost import settings
- exe_path=settings.Locate('msms', search_paths=['/opt/app','/home/app'],
- env_name='MSMS', search_system_paths=True)
- print exe_path
-
-The :func:`~ost.settings.Locate` command looks for the program with the name
-`msms`. If env_name is set, it first looks if an environment variable with the
-name `MSMS` is set. If not, all paths in search_paths are searched. If the
-executable could still not be found and search_system_paths is set to True, the
-binary search paths are searched. If the executable could not be found, a
-:exc:`~ost.FileNotFound` exception is raised with a detailed description where
-Locate was searching for the executable.
-
-Prepare All Files
---------------------------------------------------------------------------------
-
-The preparation of the necessary files is very dependent on the external program. Often it is useful to generate a temporary directory or file. For this, the python module tempfile is very handy.
-
-An example how to generate a temporary directory, open a file in this directory and write the position and radius of all atoms into this file is shown here:
-
-.. code-block:: python
-
- import tempfile
- import os
-
- # generate a temporary directory
- tmp_dir_name=tempfile.mkdtemp()
- print 'temporary directory:',tmp_dir_name
-
- # generate and open a file in the temp directory
- tmp_file_name=os.path.join(tmp_dir_name,"entity")
- tmp_file_handle=open(tmp_file_name, 'w')
- print 'temporary file:',tmp_file_handle
-
- # write position and radius of all atoms to file
- for a in entity.GetAtomList():
- position=a.GetPos()
- tmp_file_handle.write('%8.3f %8.3f %8.3f %4.2f\n' % (position[0],
- position[1], position[2], a.GetProp().radius))
-
- # close the file
- tmp_file_handle.close()
-
-Execute the External Program
---------------------------------------------------------------------------------
-
-The external program can be executed from python using the python module subprocess.
-
-To run the external program msms from the above example, with the temporary file generated before, we can use the following:
-
-.. code-block:: python
-
- import subprocess
-
- # set the command to execute
- command="%s -if %s -of %s" % (exe_path,
- tmp_file_name, tmp_file_name)
- print 'command:',command
-
- # run the executable with the command
- proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
- stdout_value, stderr_value = proc.communicate()
-
- #check for successful completion of msms
- if proc.returncode!=0:
- print "WARNING: msms error\n", stdout_value
- raise subprocess.CalledProcessError(proc.returncode, command)
-
- # print everything written to the command line (stdout)
- print stdout_value
-
-Read Generated Output
---------------------------------------------------------------------------------
-
-The last step includes reading of generated files (like in the case of msms) and/or processing of the generated command line output.
-
-Here we first print the command line output and then load the generated msms surface and print the number of vertex points:
-
-.. code-block:: python
-
- # print everything written to the command line (stdout)
- print stdout_value
-
- # read msms surface from file
- surface=io.LoadSurface(tmp_file_name, "msms")
- print 'number of vertices:',len(surface.GetVertexIDList())
diff --git a/doc/build/_sources/geom/composite.txt b/doc/build/_sources/geom/composite.txt
deleted file mode 100644
index 0271a206bc9d82d42a7661a58a3ab73deac27f2f..0000000000000000000000000000000000000000
--- a/doc/build/_sources/geom/composite.txt
+++ /dev/null
@@ -1,529 +0,0 @@
-Geometric Objects
-================================================================================
-
-.. currentmodule:: ost.geom
-
-Geometrical Objects in Two Dimensions
---------------------------------------------------------------------------------
-
-.. class:: Line2()
- Line2(from, to)
-
- Parametric line in two dimensions as defined by an origin and a normalized
- direction vector. The first constructor creates a line with origin (0,0) and
- direction along the x axis. The second signature creates a line originating
- from `from` and pointing towards `to`.
-
- .. method:: At(t)
-
- Returns the point on the line at (signed) distance t from origin.
-
- :param t: free parameter
- :type t: float
- :rtype: :class:`Vec2`
-
-
- .. method:: GetOrigin()
-
- Returns the origin of the line: Also available as :attr:`origin`.
-
- :rtype: :class:`Vec2`
-
- .. method:: GetDirection()
-
- Returns the normalized direction vector. Also available as
- :attr:`direction`.
-
- :rtype: :class:`Vec2`
-
- .. attribute:: direction
-
- .. attribute:: origin
-
-
-.. class:: Rectangle2()
- Rectangle2(top_left, bottom_right)
-
- Axis aligned rectangle. The first signature creates a rectangle with top-left
- corner (-1, -1) and bottom-right corner (1, 1), wheras the second method
- allows to set the top-left and bottom-right corners directly.
-
- :type top_left: :class:`Vec2`
- :param top_left: The top-left corner
- :param bottom_right: The bottom-right corner
- :type bottom_right: :class:`Vec2`
-
- .. method:: GetWidth()
-
- Returns the width of the rectangle. Also available as :attr:`width`.
-
- .. method:: GetHeight()
-
- Returns the height of the rectangle. Also available as :attr:`height`.
-
- .. attribute:: width
-
- :type: float
-
- .. attribute:: height
-
- :type: float
-
- .. method:: GetStart()
-
- Get top-left corner
-
- :rtype: :class:`Vec2`
-
- .. method:: GetEnd()
-
- Get bottom-right corner
-
- :rtype: :class:`Vec2`
-
- .. method:: SetStart(top_left)
-
- Set top-left corner, leaving the bottom-right corner untouched.
-
- .. method:: SetEnd(bottom_right)
-
- Set the bottom-right corner, leaving the top-left corner untouched.
-
-.. class:: Circle2()
- Circle2(circle)
- Circle2(center, radius)
-
- The first signature creates a circle centered at (0, 0) and radius 1.0. The
- second signature creates a circle with the same paramters as `circle`. The
- third signature creates a new circle with given center and radius.
-
- .. method:: SetCenter(center)
-
- Set center of circle
-
- :type center: :class:`Vec2`
- :param center: The new center
-
- .. method:: SetRadius(radius)
-
- Set radius of circle
-
- :type radius: float
- :param center: The new radius
-
- .. method:: GetCenter()
-
- Returns the center of the circle
-
- .. method:: GetRadius()
-
- Returns the radius of the circle
-
- .. method:: GetArea()
-
- Returns the area of the circle
-
- .. method:: GetCircumference()
-
- Returns the circumference of the circle
-
-
-.. class:: Ellipse2()
- Ellipse2(center, a, b, gamma)
-
- An ellipse is defined by a center, two principal axis and gamma that
- defines the angle between the first principal axis an the x-axis.
-
- .. method:: At(t)
-
- ?
-
- .. method:: AtAngle(angle)
-
- ?
-
- .. method:: GetBoundingBox()
-
- Returns the bounding rectangle (axis-aligned) of the ellipse
-
- :rtype: :class:`Rectangle2`
-
-
- .. method:: GetA()
-
- Returns the first principal-axis
-
- .. method:: GetB()
-
- Returns the second principal-axis
-
- .. method:: GetGamma()
-
- Returns the angle of the first principal axis to the x-axis
-
- .. method:: GetArea()
-
- Returns the area of the ellipse
-
- .. method:: GetOrigin()
-
- Returns the center of the ellipse
-
- .. method:: SetA(a)
-
- Set the length of the first principal axis
-
- .. method:: SetB(b)
-
- Set the length of the second principal axis
-
- .. method:: SetGamma(gamma)
-
- Set the angle of the first principal axis to the x-axis
-
- .. method:: SetOrigin(ori)
-
- Set the center of the ellipse
-
-Geometrical Objects in Three Dimensions
--------------------------------------------------------------------------------
-
-.. class:: Line3()
- Line3(from, to)
-
- Parametric line in three dimensions as defined by an origin and a normalized
- direction vector. The first constructor creates a line with origin (0,0) and
- direction along the x axis. The second signature creates a line originating
- from `from` and pointing towards `to`.
-
- .. method:: At(t)
-
- Returns the point on the line at (signed) distance t from origin.
-
- :param t: free parameter
- :type t: float
- :rtype: :class:`Vec3`
-
-
- .. method:: GetOrigin()
-
- Returns the origin of the line: Also available as :attr:`origin`.
-
- :rtype: :class:`Vec3`
-
- .. method:: GetDirection()
-
- Returns the normalized direction vector. Also available as
- :attr:`direction`.
-
- :rtype: :class:`Vec3`
-
- .. attribute:: direction
-
- :type: :class:`Vec3`
-
- .. attribute:: origin
-
- :type: :class:`Vec3`
-
-.. class:: Plane()
- Plane(p1, p2, p3)
- Plane(x, y, z, p)
- Plane(line, point)
- Plane(point, normal)
-
- A plane in 3d-space. The plane can be constructed by either passing in 3
- points (p1, p2, p3), a normal and a point, the four parameters that define the
- implicit plane equation (`x`, `y`, `z`, `p`) or a line and a point.
-
- .. method:: GetNormal()
-
- Returns the normal of the plane. Also available as :attr:`normal`
-
- :rtype: :class:`Vec3`
-
- .. method:: GetP()
-
- Returns the plane offset, i.e. the projection of any point on the plane onto
- the normal. Also available as :attr:`p`.
-
- :rtype: float
-
- .. method:: GetOrigin()
-
- Get the origin of the plane. Also available as :attr:`origin`.
-
- :rtype: :class:`Vec3`
-
- .. attribute:: origin
-
- :type: :class:`Vec3`
- .. attribute:: normal
-
- :type: :class:`Vec3`
-
- .. attribute:: p
-
- :type: float
-
-
-.. class:: Sphere()
- Sphere(center, radius)
-
- Represents a sphere in 3d space. The first constructor creates a sphere with
- radius 1, centered at (0, 0, 0), the second allows you to set the radius and
- center directly.
-
- :param center: The center
- :type center: :class:`Vec3`
- :param radius: The radius
- :type radius: float
-
- .. attribute:: radius
-
- The radius of the sphere. Read-write. Also available as :meth:`GetRadius`,
- :meth:`SetRadius`.
-
- :type: float
-
- .. attribute:: origin
-
- The center of the sphere. Read-write. Also available as :meth:`GetOrigin`,
- :meth:`SetOrigin`.
-
- :type: :class:`Vec3`
-
- .. method:: GetOrigin()
-
- See :attr:`origin`
-
- .. method:: SetOrigin(origin)
-
- See :attr:`origin`
-
- .. method:: GetRadius()
-
- See :attr:`radius`
-
- .. method:: SetRadius(radius)
-
- See :attr:`radius`
-
-.. class:: AlignedCuboid(min, max)
-
- Axis aligned cuboid is a cuboid whose axes are aligned to the x-, y-, and z-
- axes of the coordinate system. For arbitrarily oriented bounding cuboid
- class, see :class:`Cuboid`.
-
- .. method:: GetMin()
-
- Get minimum coordinate, i.e. the lower bound of x-, y-, and z for
- any point in the cuboid
-
- :rtype: :class:`Vec3`
-
- .. method:: GetMax()
-
- Get maximum coordinate, i.e. the upper bound of x-, y-, and z for
- any point in the cuboid.
-
- :rtype: :class:`Vec3`
-
-.. class:: CuboidAxis()
- CuboidAxis(dir, half_extent)
-
- A cuboid axis is defined by a half-extent, and a direction vector. This class
- is used in together with the :class:`Cuboid` class.
-
- :param dir: Direction vector, will be normalized
- :type dir: :class:`Vec3`
- :param half_extent: The half extent
- :type half_extent: float
-
- .. attribute:: vector
-
- The normalized direction vector of the cuboid axis. Also available as
- :meth:`GetVector`
-
- :type: :class:`Vec3`
-
- .. attribute:: half_extent
-
- The half extent of the cuboid axis is the magnitude of the cuboid
- axis measured from the center to the corner. Also available as
- :meth:`GetHalfExtent`
-
- :type: float
-
- .. attribute:: extent
-
- The extent of the cuboid axis. This value is always twice the
- :attr:`half_extent`. Read-only. Also available as
- :meth:`GetExtent`.
-
- :type: float
-
- .. method:: GetHalfExtent()
-
- See :attr:`half_extent`
- .. method:: GetExtent()
-
- See :attr:`extent`
-
- .. method:: GetVector()
-
- See :attr:`vector`
-
-.. class:: Cuboid(center, axis_a, axis_b, axis_c)
-
- An arbitrarily oriented cuboid defined by a center and 3 axis. The 3 cuboid
- axis are stored in the order they are passed to the constructor. This means,
- that there is no guarantee that the 3 axes form a right-handed coordinate
- system. If a right-handed coordinate system is a requirement, you have to
- ensure this on your own:
-
- .. code-block:: python
-
- center=...
- axis_a=geom.CuboidAxis(...)
- axis_b=geom.CuboidAxis(...)
- axis_c=geom.CuboidAxis(geom.Cross(axis_a.vector, axis_b.vector), ...)
-
- cuboid=geom.Cuboid(center, axis_a, axis_b, axis_c)
-
- :param center: The center
- :type center: :class:`Vec3`
- :param axis_a: The first axis
- :type axis_a: :class:`CuboidAxis`
- :param axis_b: The second axis
- :type axis_b: :class:`CuboidAxis`
- :param axis_c: The third axis
- :type axis_c: :class:`CuboidAxis`
-
- .. attribute:: center
-
- The center of the cuboid.
-
- :type: :class:`Vec3`
-
- .. attribute:: axis_a
-
- The first cuboid axis
-
- :type: :class:`CuboidAxis`
-
- .. attribute:: axis_b
-
- The second cuboid axis
-
- :type: :class:`CuboidAxis`
-
- .. attribute:: axis_c
-
- The third cuboid axis
-
- :type: :class:`CuboidAxis`
-
-Operations on Geometrical Objects
---------------------------------------------------------------------------------
-
-.. function:: Angle(lhs, rhs)
-
- Calculate the angle (in radians) between `lhs` and `rhs`.
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :rtype: float
-
-.. function:: IntersectionPoint(lhs, rhs)
-
- Calculates and returns the intersection point between `lhs` and `rhs`
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :raises: :exc:`GeomException` when the two objects do not intersect
- :rtype: :class:`Vec3` (:class:`Vec2` in case of :class:`Line2`)
-
-.. function:: IntersectionLine(plane2, plane2)
-
- Returns the intersection line between `plane1` and `plane2`.
-
- :param plane1: The first plane
- :type plane1: :class:`Plane`
- :param plane2: The second plane
- :type plane2: :class:`Plane`
-
- :raises: :exc:GeomException if the two planes are parallel.
-
-.. function:: Distance(lhs, rhs)
-
- Returns the minimal distance between `lhs` and `rhs`.
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :rtype: float
-
-.. function:: IsOnLine(line, point, epsilon=geom.EPSILON)
-
- Check whether `point` lies on `line` and returns true if point i no further
- away than `epsilon`.
-
- :rtype: bool
-
-.. function:: IsInPlane(plane, object, epsilon=geom.EPSILON)
-
- Check whether `object` lies in `plane` and returns true if the difference is
- no bigger than `epsilon`.
-
- :param plane: The plane
- :type plane: :class:`Plane`
- :param object: The object
- :type object: :class:`Vec3` or :class:`Line3`
-
- :rtype: bool
-
-.. function:: AreParallel(lhs, rhs, epsilon=geom.EPSILON)
-
- Check whether `lhs` and `rhs` are parallel and returns true, if the difference
- is below the given treshold `epsilon`.
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :rtype: bool
-
-.. function:: AreIntersecting(line1, line2, epsilon=geom.EPSILON)
-
- Check whether `line1` and `line2` are intersecting and returns true, if they
- intersect below the given threshold `epsilon`.
-
- :param lhs: First line
- :type lhs: :class:`Line2`, :class:`Line3`
-
- :param rhs: Second line
- :type rhs: :class:`Line2`, :class:`Line3`
-
- :rtype: bool
-
-
-
-.. function:: IsInSphere(sphere, point)
-
- Check whether the `sphere` contains `point`.
-
- :rtype: bool
\ No newline at end of file
diff --git a/doc/build/_sources/geom/geom.txt b/doc/build/_sources/geom/geom.txt
deleted file mode 100644
index d0412a1340ae8ebf248e3193f381801f85d0b05b..0000000000000000000000000000000000000000
--- a/doc/build/_sources/geom/geom.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-:mod:`~ost.geom` -- vectors, matrices and geometrical objects
-================================================================================
-
-.. module:: ost.geom
- :synopsis: Functions and classes for vectors, matrices and geometrical
- objects in 2, 3 and four dimensions
-
-The geom modules contains functions and classes for vectors, matrices and other
-geometrical objects in 2, 3 and four dimensions.
-
-
-.. toctree::
-
- vec
- mat
- composite
\ No newline at end of file
diff --git a/doc/build/_sources/geom/mat.txt b/doc/build/_sources/geom/mat.txt
deleted file mode 100644
index c8736733a7a18533cf18e6fcf40ddecf6b3a52c7..0000000000000000000000000000000000000000
--- a/doc/build/_sources/geom/mat.txt
+++ /dev/null
@@ -1,167 +0,0 @@
-Matrices
-================================================================================
-
-.. currentmodule:: ost.geom
-
-The :mod:`~ost.geom` module defines matrices in two, three and four dimensions.
-All matrices store the values in row-major order, meaning that, the matrix ((1,
-2), (3,4)) stores the values as (1, 2, 3, 4). This is illustrated in
-the following code examples:
-
-.. code-block:: python
-
- m=geom.Mat2(1, 2, 3, 4)
- print m # will print {{1,2},{3,4}}
- print m[(0,0)], m[(0,1)], m[(1,0)], m[(1,1)] # will print 1, 2, 3, 4
-
-Matrices support arithmetic via overloaded operators. The following operations are
-supported:
-
- * adding and subtracting two matrices
- * negation
- * multiplication of matrices
- * multiplying and dividing by scalar value
-
-The Matrix Classes
---------------------------------------------------------------------------------
-
-.. class:: Mat2()
- Mat2(d00, d01, d10, d11)
-
- 2x2 real-valued matrix. The first signature creates a new identity matrix. The
- second signature initializes the matrix in row-major order.
-
- .. staticmethod:: Identity()
-
- Returns the 2x2 identity matrix
-
-
-.. class:: Mat3()
- Mat3(d00, d01, d02, d10, d11, d12, d20, d21, d22)
-
- 3x3 real-valued matrix. The first signature creates a new identity matrix. The
- second signature initializes the matrix in row-major order.
-
- .. staticmethod:: Identity()
-
- Returns the 3x3 identity matrix
-
-.. class:: Mat4()
- Mat4(d00, d01, d02, d03, d10, d11, d12, d13, d20, d21, d22, d23, d30, d31, d32, d33)
-
- 4x4 real-valued matrix. The first signature creates a new identity matrix. The
- second signature initializes the matrix in row-major order.
-
- .. method:: ExtractRotation()
-
- Returns the 3x3 submatrix
-
- .. method:: PasteRotation(mat)
-
- Set the 3x3 submatrix of the top-left corner to `mat`
-
- .. method:: ExtractTranslation()
-
- Extract translation component from matrix. Only meaningful when matrix
- is a combination of rotation and translation matrices, otherwise the result
- is undefined.
-
- .. PasteTranslation(trans)
-
- Set the translation component of the matrix to `trans`
-
- :param trans: The translation
- :type trans: :class:`Vec3`
-
- .. staticmethod:: Identity()
-
- Returns the 4x4 identity matrix
-
-Functions Operating on Matrices
---------------------------------------------------------------------------------
-.. function:: Equal(lhs, rhs, epsilon=geom.EPSILON)
-
- Compares the two matrices `lhs` and `rhs` and returns True, if all
- of the element-wise differences are smaller than epsilon. `lhs`
- and `rhs` must be matrices of the same dimension.
-
- :param lhs: First matrix
- :type lhs: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
- :param rhs: Second matrix
- :type rhs: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
-
-.. function:: Transpose(mat)
-
- Returns the transpose of `mat`
-
- :param mat: The matrix to be transposed
- :type lhs: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
-
-.. function:: Invert(mat)
-
- Returns the inverse of `mat`
-
- :param mat: The matrix to be inverted
- :type mat: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
-
- What happens when determinant is 0?
-
-.. function:: CompMultiply(lhs, rhs)
-
- Returns the component-wise product of `lhs` and `rhs`. `lhs` and
- `rhs` must be vectors of the same dimension.
-
- :param lhs: The lefthand-side vector
- :type lhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
- :param rhs: The righthand-side vector
- :type rhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
-
-.. function:: CompDivide(lhs, rhs)
-
- Returns the component-wise quotient of `lhs` divided by `rhs`. `lhs`
- and `rhs` must be vectors of the same dimension.
-
- :param lhs: The lefthand-side vector
- :type lhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
- :param rhs: The righthand-side vector
- :type rhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
-
-.. function:: Det(mat)
-
- Returns the determinant of `mat`
- :param mat: A matrix
- :type mat: :class:`~Mat2`, :class:`~Mat3` or :class:`~Mat4`
-
-.. function:: Minor(mat, i, j)
-
- Returns the determinant of the 2x2 matrix generated from `mat` by
- removing the ith row and jth column.
-
-.. function:: EulerTransformation(phi, theta, xi)
-
- Returns a rotation matrix for the 3 euler angles `phi`, `theta`, and
- `xi`. The 3 angles are given in radians.
-
-
-.. function:: AxisRotation(axis, angle)
-
- Returns a rotation matrix that represents a rotation of `angle`
- around the `axis`.
-
- :param axis: The rotation axis. Will be normalized
- :type axis: :class:`Vec3`
- :param angle: Rotation angle (radians) in clockwise direction when
- looking down the axis.
-
-.. function:: OrthogonalVector(vec)
-
- Get arbitrary vector orthogonal to `vec`. The returned vector is of length
- 1, except when `vec` is a zero vector. In that case, the returned vector is
- (0, 0, 0).
-
- :param vec: A vector of arbitrary length
- :type vec: :class:`Vec3`
\ No newline at end of file
diff --git a/doc/build/_sources/geom/vec.txt b/doc/build/_sources/geom/vec.txt
deleted file mode 100644
index d3876bcb1f9b46049869a3be84e51bdef9ff7e23..0000000000000000000000000000000000000000
--- a/doc/build/_sources/geom/vec.txt
+++ /dev/null
@@ -1,190 +0,0 @@
-Vectors
-================================================================================
-.. currentmodule:: ost.geom
-
-
-The :class:`Vec2`, :class:`Vec3`, :class:`Vec4` classes implement vectors in 2,
-3 and four dimensions. They support basic arithmetic via overloaded operators.
-Essentially, the following basic operations are available:
-
- * adding and subtracting two vectors
- * negation
- * multiplying and dividing by scalar value
-
-This is shown in the following example:
-
-.. code-block:: python
-
- vec_a=geom.Vec2(1, 0)
- vec_b=geom.Vec2(0, 1)
- print vec_a, vec_b
- print vec_a+vec_b
- print vec_a*3-vec_b
-
-The standard vector operations are implemented as :ref:`free standing functions
-<vector-functions>`:
-
-
-.. code-block:: python
-
- vec_a=geom.Vec3(1, 0, 0)
- vec_b=geom.Vec3(0, 1, 0)
-
- print geom.Dot(vec_a, vec_b)
- print geom.Cross(vec_a, vec_b)
-
- print geom.Normalize(geom.Vec3(1, 1, 0))
-
- print geom.Length(geom.Vec3(1, 1, 1))
-
-
-Vector Classes
---------------------------------------------------------------------------------
-.. class:: Vec2([x=0.0, y=0.0, z=0.0])
- Vec2(vec)
-
- Real-valued vector in 2 dimensions.
-
- :param x: x coordinate
- :type x: float or int
- :param y: y coordinate
- :type y: float or int
- :param vec: the coordinates are set to the coordinates of vec. If vec is a
- :class:`Vec2`, the coordinates are copied directly, If vec is a
- :class:`Vec3`, the x and y coordinates are set to the
- coordinates of vec and z is silently swallowed. If vec is of
- type :class:`Vec4`, x and y are divided by the homogenous
- coordinate w, raising a DivideByZeroException when w is zero.
- :type vec: Vec2, Vec3 or Vec4
-
- .. attribute:: x
-
- The x-coordinate of the vector.
-
- :type: float
-
- .. attribute:: y
-
- The y-coordinate of the vector.
-.. class:: Vec3([x=0.0, y=0.0, z=0.0])
- Vec3(vec)
-
- Real-valued vector in 3 dimensions.
-
- :param x: x coordinate
- :param y: y coordinate
- :param z: z coordinate
- :param vec: the coordinates are set to the coordinates of vec. If vec is a
- :class:`Vec3`, the coordinates are copied directly, If vec is a
- :class:`Vec2`, the x and y coordinates are set to the
- coordinates of vec and z is initialized to zero. If vec is of
- type :class:`Vec4`, x, y and z are divided by homogenous
- coordinate w, raising a DivideByZeroException when w is zero.
- :type vec: Vec2, Vec3 or Vec4
-
- .. attribute:: x
-
- The x-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: y
-
- The y-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: z
-
- The z-coordinate of the vector.
-
- :type: float or int
-
-.. class:: Vec4([x=0.0, y=0.0, z=0.0, w=1.0])
- Vec4(vec)
-
- Real-valued vector in 4 dimensions.
-
- :param x: x coordinate
- :type x: float or int
- :param y: y coordinate
- :type y: float or int
- :param z: z coordinate
- :type z: float or int
- :param w: w (homogenous) coordinate
- :type w: float or int
- :param vec: the coordinates are set to the coordinates of vec. If vec is a
- :class:`Vec4`, the coordinates are copied directly, If vec is a
- :class:`Vec2`, the x and y coordinates are set to the
- coordinates of vec and z and w are initialized to 0 and 1,
- respectively. If vec is of type :class:`Vec4`, x, y and z are
- divided by homogenous coordinate w, raising a
- DivideByZeroException when w is zero.
-
- .. attribute:: x
-
- The x-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: y
-
- The y-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: z
-
- The z-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: w
-
- The homogenous coordinate.
-
- :type: float or int
-
-
-.. _vector-functions:
-
-Functions Operating on Vectors
---------------------------------------------------------------------------------
-
-.. function:: Cross(vec_a, vec_b)
-
- Cross product of `vec_a` and `vec_b`
-
- :type vec_a: Vec3
- :type vec_b: Vec3
-
-.. function:: Dot(vec_a, vec_b)
-
- Dot (scalar) product of `vec_a` and `vec_b`
-
- :param vec_a: first vector
- :type vec_a: Vec3
- :param vec_b: second vector
- :type vec_b: Vec3
-
-.. function:: Length(vec)
-
- Length of vector
-
- :param vec:
- :type vec: Vec2, Vec3 or Vec4
-
-.. function:: Length2(vec)
-
- Returns the squared length of `vec`
-
- :param vec:
- :type vec: Vec2, Vec3 or Vec4
-
-.. function:: Normalize(vec)
-
- Returns a normalized version of `vec`
-
- :param vec: Vector to be normalized
- :type vec: Vec2, Vec3 or Vec4
-
diff --git a/doc/build/_sources/gui/gui.txt b/doc/build/_sources/gui/gui.txt
deleted file mode 100644
index 457752167dc7e27f90ecab0c1e74c1d5e9af681a..0000000000000000000000000000000000000000
--- a/doc/build/_sources/gui/gui.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-:mod:`~ost.gui` -- Graphical User Interface
-================================================================================
-
-The GUI of OpenStructure is designed to be intuitive, flexible and extensible. Most of the widgets are organized in a big main window which is divided into four parts:
-the main area and three panels containing one or more smaller widgets:
-
-.. image:: images/100208_OpenStructure_UI_Colored.png
-
diff --git a/doc/build/_sources/img/alg/alg.txt b/doc/build/_sources/img/alg/alg.txt
deleted file mode 100644
index 3e0f673dedc821d52a781f873d5d21d615f00794..0000000000000000000000000000000000000000
--- a/doc/build/_sources/img/alg/alg.txt
+++ /dev/null
@@ -1,67 +0,0 @@
-:mod:`~ost.img.alg` - Image Processing Algorithms
-================================================================================
-
-.. module:: ost.img.alg
- :synopsis: Image processing algorithms
-
-Usage of Image Algorithms
---------------------------------------------------------------------------------
-
-Image algorithms are objects. To execute them, the algorithms are applied to an
-image by passing it to the :meth:`ost.img.ImageHandle.Apply` or
-:meth:`ost.img.ImageHandle.ApplyIP` method:
-
-.. code-block:: python
-
- image=img.CreateImage(img.Size(200, 200))
- fft_image=image.Apply(img.alg.FFT())
- image.ApplyIP(img.alg.FFT())
-
-
-.. class:: FFT
-
- Fast Fourier Transforms the image. The FFT algorithms is aware of the
- image's domain. The following rules apply:
-
- * SPATIAL -> HALF_FREQUENCY
- * HALF_FREQUENCY -> SPATIAL
- * FREQUENCY -> COMPLEX_SPATIAL
- * COMPLEX_SPATIAL -> FREQUENCY
-
-.. class:: GaussianFilter(sigma=1.0)
-
- Applies a gaussian filter to the supplied image. Sigma is given in pixels.
-
- Implemented after I.T.Young, L.J. van Vliet,"Recursive implementation of the
- Gaussian filter", Signal Processing, 44(1995), 139-151
-
-Filters in Fourier Space
---------------------------------------------------------------------------------
-
-The following filters operate in Fourier Space. If the image they are applied on is in spatial domain, they will first be converted to frequency domain and then converted back after the filter has been applied.
-
-.. class:: LowpassFilter(freq_limit)
-
- Filters an image by masking out frequencies higher than
- `freg_limit`.
-
- .. method:: GetLimit()
-
- Returns the frequency limit
-
- .. method:: SetLimit(freq)
-
- Set the frequency limit
-
-.. class:: HighpassFilter
-
- Filters an image by masking out frequences lower than `freq_limit`
-
- .. method:: GetLimit()
-
- Returns the frequency limit
-
- .. method:: SetLimit(freq)
-
- Set the frequency limit
-
\ No newline at end of file
diff --git a/doc/build/_sources/img/base/img.txt b/doc/build/_sources/img/base/img.txt
deleted file mode 100644
index 53243c9042291e6151667d154c4c411d3a543f8b..0000000000000000000000000000000000000000
--- a/doc/build/_sources/img/base/img.txt
+++ /dev/null
@@ -1,186 +0,0 @@
-:mod:`~ost.img` Images and Density Maps
-================================================================================
-
-.. module:: ost.img
- :synopsis: Images and density maps
-
-Introduction : The ImageHandle
---------------------------------------------------------------------------------
-
-OpenStructure offers extensive processing capabilities for planar 2d images and
-3d maps using the img module. Images are manipulated through the use of
-dox[ost::img::ImageHandle|ImageHandles].
-
-ImageHandles provide a clean and efficient interface to interact with images and
-maps. An :class:`ImageHandle` can store an image in either real ('SPATIAL') or
-Fourier ('FREQUENCY') space and always keep track of the currently active
-domain. This means,for example that one can apply a Fourier Transformation to an
-ImageHandle containing a 'SPATIAL' image and the ImageHandle will correctly
-identify the new active domain as 'FREQUENCY'. The ImageHandle also understands,
-for example, that applying a Fourier Transform to a centrosymmetric 'FREQUENCY'
-image results in a real 'SPATIAL' image, but applying it to a
-non-centrosymmetric one results in a complex 'SPATIAL' image.
-
-Furthermore, the ImageHandle will make sure that real and Fourier space
-information about the image are always in sync. If, for example, the pixel
-sampling is changed while the current active domain is real space, the pixel
-sampling in Fourier space will be adjusted accordingly, and vice versa.
-
-Moreover, the ImageHandle allows the extraction of both complex and real numeric
-values from images in any active domain. If the domain is complex in nature, but
-a real numeric value is requested, the amplitude of the complex number will be
-returned. If the numerical nature of the domain is real and a complex number is
-requested, the complex part will be set to 0.
-
-Creating and visualizing ImageHandles
---------------------------------------------------------------------------------
-As a first step, enter the following lines in the OpenStructure python console:
-
- .. code-block:: python
-
- im=img.CreateImage(img.Size(200,200))
-
-This will create an empty, 2D image, with a height and width of 200 pixels, whose
-origin (ie the pixel with the coordinates <0,0>) is in the top-left corner.
-
- .. code-block:: python
-
- v=gui.CreateDataViewer(im)
-
-A viewer window will pop up (see below), showing a white frame on a black background.
-The inner area of the white frame is the image, which is empty.
-
-Reading and writing into an image
--------------------------------------------------------------------------------
-
-Data can be read and written from and into an image using the following commands:
-
- .. code-block:: python
-
- # writes the real value 23.4 into pixel 10,10
- im.SetReal(img.Point(10,10),23.4)
- # reads the value in pixel 10,10
- val=im.GetReal(img.Point(10,10))
-
-The complex equivalents are also available
-
- .. code-block:: python
-
- # writes the complex value value 2+3j into pixel 10,10
- im.SetComplex(img.Point(10,10),2+3j)
- # reads the value in pixel 10,10
- val=im.GetComplex(img.Point(10,10))
-
-The image knows in which domain it is, and will adjust the type of data being written
-accordingly. For example, if one writes a complex value in a 'SPATIAL' image, the value
-will be automatically converted to a real one by taking the amplitude of the complex number
-On the other hand, if one writes a real value in a 'FREQUENCY' image, the value is automatically
-converted to complex by setting the imaginary part to 0.
-
-## Applying algorithms
-
-Let us fill the image with random values.
-
- .. code-block:: python
-
- rand_alg = img.alg.Randomize() # create algorithm object
- im.ApplyIP( rand_alg ) # apply algorithm object in-place
-
-As you can see, applying an algorithm is conceptually a two-step process. First,
-an instance of an algorithm class is created, yielding an algorithm object (in
-this case 'rand\_alg'). In a second step, the algorithm object is applied to an
-image, either in-place, modifying the image, or out-of-place, leaving the
-original image untouched, and returning the result as a new image. Note that the
-in-place/out-of-place logic is decoupled from the algorithm object.
-
-Now that we have some (noisy) data present, let us run another algorithm, this
-time a Gaussian filter with a sigma of 4 pixel.
-
- .. code-block:: python
-
- im.ApplyIP( img.alg.GaussianFilter(4.0) ) # apply temporary algorithm object in-place
-
-As you can see, it is not always necessary to create an independent algorithm
-instance first, in many cases a temporary object will suffice (this applies to
-the randomization algorithm as well, 'im.ApplyIP(alg.Randomize())' would have
-been fine). However, when used this way, the algorithm class will cease to exist
-as soon as the algorithm is applied. This can be important if the algorithm
-stores some values that need to be recovered later. For example:
-
- .. code-block:: python
-
- stat=img.alg.Stat()
- im.ApplyIP(stat)
- mean=stat.GetMean()
-
-Algorithms are stateful objects and can store values. The 'Stat' algorithm
-computes basic statistics about the image it is applied on (maximum and minimum
-values, standard deviations, etc). The data are stored within the algorithm
-instance and can be recovered using the algorithm's methods. It would obviously
-make very little sense not to create an instance of the 'Stat' algorithm. When
-the algorithms ceases to exist, all information would be lost.
-
-Applying a Fourier Transform
---------------------------------------------------------------------------------
-
-An image is Fourier-transformed using the 'img.alg.FFT()' algorithm object:
-
- .. code-block:: python
-
- im=io.LoadImage("imagename.tif") # load the image
- # create an instance of the fft algorithm object
- fft=img.alg.FFT()
- # do the actual Fourier transformation
- im_ft=im.Apply(fft)
- # back-transform
- im2 = im_ft.Apply(fft)
- # if this is run from within the dng graphical frontend, open viewers to
- # look at the images
- gui.CreateDataViewer(im)
- gui.CreateDataViewer(im_ft)
- gui.CreateDataViewer(im2)
-
-It is not really necessary to use the 'fft' variable to store the 'im.alg.FFT()'
-instance, a temporary object can be used, since the 'FFT' algorithm object is stateless. In addition, the algorithm can be applied in-place to avoid the
-creation of a second image:
-
- .. code-block:: python
-
- im=io.LoadImage("imagename.tif") # load the image
- # do the actual Fourier transformation, in-place using temporary object
- im.ApplyIP(alg.FFT())
- # repeating this command will do the back-transform
- im.ApplyIP(alg.FFT())
-
-As said before, the 'alg.FFT()' algorithm does not require a direction to be given, this is implicitly
-determined by the active domain of the underlying image state: a 'SPATIAL' image will always be
-transformed to the 'FREQUENCY' domain, and vice-versa.
-
-Extracting and Pasting Images
---------------------------------------------------------------------------------
-
-An image can be extracted and pasted into another image using the 'Extract()'
-and 'Paste()' member functions:
-
- .. code-block:: python
-
- # load the image
- im=io.LoadImage("imagename.tif")
- # generate a subimage from the region going from (10,10) to (30,30)
- im2=im.Extract(img.Extent(img.Point(10,10),img.Point(30,30)))
- # generate an empty image with the same size as the original image
- im3=img.CreateImage(im.GetExtent())
- # paste the subimage into the empty image
- im3.Paste(im2)
-
-Note that the extent is fully honored for the paste operation, i.e. only the
-region where the pasted-to and the pasted-in image overlap will be affected.
-
-
-
- ..
- | | | |
- |:-------------------------------------------------:|:-------------------------------------------------------------------:|:------------------------------------------------------------------------:|
- |![Empty Image] (docs/tut/dv1.jpg "Empty Image") | ![After Randomization] (docs/tut/dv2.jpg "After Randomization") | ![After Gaussian Filtering] (docs/tut/dv3.jpg "After Randomization") |
- |Empty Image | After Randomization | After Gaussian Filtering |
-
\ No newline at end of file
diff --git a/doc/build/_sources/index.txt b/doc/build/_sources/index.txt
deleted file mode 100644
index c70e751c08e24eda54a2318c11ac46f829b97810..0000000000000000000000000000000000000000
--- a/doc/build/_sources/index.txt
+++ /dev/null
@@ -1,41 +0,0 @@
-OpenStructure documentation
-================================================================================
-
-.. toctree::
- :maxdepth: 2
-
-Introduction
---------------------------------------------------------------------------------
-
-.. toctree::
- :maxdepth: 2
-
- intro
- install
-
-Modules
---------------------------------------------------------------------------------
-
-.. toctree::
- :maxdepth: 2
-
- base/generic
- img/base/img
- img/alg/alg
- geom/geom
- conop/conop
- mol/base/mol
- seq/base/seq
- base/base
- io/io
- gui/gui
-
-Extending OpenStructure
---------------------------------------------------------------------------------
-
-.. toctree::
- :maxdepth: 2
-
- newmodule
- external
-
\ No newline at end of file
diff --git a/doc/build/_sources/install.txt b/doc/build/_sources/install.txt
deleted file mode 100644
index 86c10f7c515fd9b98f12ebbb595f0fb8b561e053..0000000000000000000000000000000000000000
--- a/doc/build/_sources/install.txt
+++ /dev/null
@@ -1,108 +0,0 @@
-Installing OpenStructure
-================================================================================
-
-This document describes how to install OpenStructure from source. If you are not planning to develop code for OpenStructure, you might be better off with one of the binaries available for download.
-
-Installing the Dependencies
---------------------------------------------------------------------------------
-
-OpenStructure uses a bunch of OpenSource libraries. If you haven't already installed them, please install them now!
-
- * `CMake <http://cmake.org>`_
- * `Eigen2 <http://eigen.tuxfamily.org>`_
- * `Boost <http://boost.org>`_
- * `libpng <http://www.libpng.org>`_
- * `Python <http://python.org>`_
- * `Qt <http://qt.nokia.com>`_
-
-When you enable support for image processing, you will need:
-
- * `FFTW3 <http://fftw.org>`_. By default, OpenStructure is compiled with single precision and thus also requires FFTW to be compiled with single precision. Most platforms offer this as a second package. If you are compiling manually, use the `--enable-single` option.
-
- * `libtiff <http://www.libtiff.org>`_
-
-
-
-If you would like to use the graphical user interface, also install:
-
- * `SIP <http://www.riverbankcomputing.co.uk/software/sip/download>`_.
- * `PyQt4 <http://www.riverbankcomputing.co.uk/software/pyqt/download>`_.
-
-In case you are compiling under Windows you have to install `Visualstudio
-2008 <http://www.microsoft.com/express/Downloads>`_. to compile the dependecies
-and OpenStructure. We recommend to compile the dependecies manually. Enter the
-directories where the dependencies are located in Tools->Options->Projects and
-Solutions->VC++ directories. Choose 'bin' directories to enter program paths to
-cmake, qmake and python, 'lib' directories to point to the location(s) of your
-dependencies.
-
-Checking out the Source
---------------------------------------------------------------------------------
-
-You can checkout the source from SVN. The repository is located at
-
- https://dng.biozentrum.unibas.ch/svn/openstructure/trunk
-
-If you are using the commandline client, type in your shell
-
- svn co https://ost.biozentrum.unibas.ch/svn/openstructure/trunk
-
-On Windows install svn clients like `tortoisesvn <http://tortoisesvn.tigris.org>`_ and use the function 'checkout' then enter the above mention URL.
-
-
-Configuring
---------------------------------------------------------------------------------
-
-
-OpenStructure uses `CMake <http://cmake.org>`_ for compiling and building the project. The next required step is to configure the build environment using cmake. You can do that by invoking `cmake` in the project directory (On Windows choose Tools->visualstudio commandline prompt from within visualstudio) :
-
- cmake . <options>
-
-There are two kinds of options: Options that let you control the building behaviour, enabling and disabling the compilation of certain modules and options that let you tell CMake where to find the dependencies. All of them are passed to CMake with via `-D<opt>=<value>`.
-
-Flag to choose build system
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-On Windows make sure you specify -G"Visual Studio 9 2008"!
-
-Flags to Control the Dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-By default, `CMake <http://cmake.org>`_ searches the standard directories for dependencies. However, on some systems, this might not be enough. Here is a short description of how CMake figures out what dependencies to take and how you can influence it.
-
- * Boost is mainly controlled via the `BOOST_ROOT` option. If boost wasn't
- found, it should be set to the prefix of the boost installation.
-
- * `QT_QMAKE_EXECUTABLE` defines the exact Qt installation to take. It should
- be set to the full path to `qmake`.
-
- * `PYTHON_ROOT` is the Python equivalent of BOOST_ROOT. It should be set to
- the prefix path containing the python binary, headers and libraries.
-
- * `SYS_ROOT` controls the general prefix for searching libraries and headers.
- By default, it is set to `/`.
-
-Build Options
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
- * `ENABLE_UI` controls whether to build the graphical user interface module. By
- default it is set to true.
- * `ENABLE_IMG` controls whether to build the image processing module. This will
- enable support for density maps, and general image processing in 1, 2 an 3
- dimensions. By default it is set to true.
-
- * `ENABLE_GFX` controls whether to build the graphics module. By default, this
- is set to true. If set to none, this implies `ENABLE_UI=NO`.
-
- * Shader support is controlled with `USE_SHADER`. By default, no shaders are
- used.
-
- * If `OPTIMIZE` is set to 1, an optimized version of OpenStructure is built.
-
-Building the Project
---------------------------------------------------------------------------------
-
-Type `make`. If you are using a multi-core machine, you can use the `-j` flag to run
-multiple jobs at once.
-
-On Windows run 'Build OpenStructure' from the build menu.
diff --git a/doc/build/_sources/intro.txt b/doc/build/_sources/intro.txt
deleted file mode 100644
index abf6e6cf9fe1ac349a9af1a8d5fd63c686bf14b9..0000000000000000000000000000000000000000
--- a/doc/build/_sources/intro.txt
+++ /dev/null
@@ -1,368 +0,0 @@
-A gentle introduction to OpenStructure
-================================================================================
-
-In this tutorial you will be learning by example how to use the OpenStructure
-framework.
-
-We assume that you already have a version of OpenStructure installed. If not,
-please refer to :doc:`install`.
-
-
-What will be covered in this tutorial?
---------------------------------------------------------------------------------
-
-This tutorial is aimed at users that would like to get their hands dirty and
-execute commands in Python and write scripts rather clicking their way through a
-shiny user interface. The user interface of OpenStructure is in a very early
-state anyway that you probably won't go far by clicking you way through...
-
-The first part of the tutorial is a walk-through of the basic functionality you
-will be using in your everyday work. You will learn how to load structure
-datasets, inspect, display them in the 3D window and save them.
-
-
-Getting ready to rumble
---------------------------------------------------------------------------------
-
-The files we will be using in the tutorial are available in the examples folder
-that comes with OpenStructure. Depending on your platform, the examples are
-located at a different location:
-
- * on *MacOS X* the files are in /Applications/OpenStructure/Examples
- * on *Linux* and *Windows* PREFIX/share/openstructure/examples, where PREFIX is
- the path to the directory containing OpenStructure.
-
-Starting DNG
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The graphical user interface of OpenStructure is called DNG (Dino/DeepView Next
-Generation). To start it,
-
- * on *MacOS X* double click DNG.app in /Applications/OpenStructure
- * on *Windows* double click dng.bat inside the PREFIX/bin directory
- * on *Linux* fire up a terminal change into the OpenStructure installation
- directory and type 'bin/dng'. If you have the binary directory in the PATH,
- typing dng is sufficient.
-
-Interactive Python Shell
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Now we will enter commands in the Python Shell (in the screenshot above, the
-python shell is located at the bottom of the main window). If you want to get
-more information on any object, function or class, the python help command may
-be useful. For example:
-
- .. code-block:: python
-
- # get list of methods of EntityView
- help(mol.EntityView)
- # get help for method Select
- help(mol.EntityView.Select)
-
-Loading and inspecting a protein structure
---------------------------------------------------------------------------------
-
-OpenStructure has a module that is dedicated to deal with input and output of
-data, including sequence alignment formats, protein structures and density data
-and images. If you are reading this tutorial you most certainly have dealt with
-protein structures before and you are most certainly aware that they are usually
-stored in Brookhaven structure files (aka PDB files). The official name for
-molecules stored in a PDB file is an entity. You will hear this word all the
-time, but you can replace the word entity with molecule in your head.
-
-
-To load a PDB file, type
-
- .. code-block:: python
-
- fragment=io.LoadPDB('/path/to/examples/entity/fragment.pdb')
-
-This will load the fragment from the specified file 'fragment.pdb' and store the result in fragment. For more information on the LoadPDB function, type
-
- .. code-block:: python
-
- help(io.LoadPDB)
-
-Now let's inspect what we just loaded:
-
- .. code-block:: python
-
- print fragment.chain_count
- print fragment.residue_count
- print fragment.atom_count
-
-As you can see, our fragment consists of one peptide chain of 12 amino acids and
-has 81 atoms in total. Now let's examine our fragment in more detail. Enter the
-command
-
- .. code-block:: python
-
- for residue in fragment.residues:
- print residue
-
-This will print a list of all residues in the fragment. Similarly to get a list
-of atoms, use:
-
- .. code-block:: python
-
- for atom in fragment.atoms:
- print atom
-
-Of course, we can also get a list of atoms grouped by residues:
-
- .. code-block:: python
-
- for residue in fragment.residues:
- print residue, 'has', residue.atom_count, 'atom(s).'
- for atom in residue.atoms:
- print ' ', atom.name, atom.pos
-
-And, for completeness, we will first group them by chain, then by residues.
-
- .. code-block:: python
-
- for chain in fragments.chains:
- print 'chain', chain.name, 'has', chain.residue_count, 'residue(s)'
- for residue in chain.residues:
- print ' ', residue, 'has', residue.atom_count, 'atom(s).'
- for atom in residue.atoms:
- print ' ', atom.name, atom.pos
-
-Aah, wait! A protein fragment would not be complete without bonds: Let's see
-what bonds we have in there:
-
- .. code-block:: python
-
- for bond in fragment.bonds:
- print bond
-
-From these short code examples we already see how the entity is structured: On
-one hand we have a hierarchy of chains, residues and atoms. On the other hand,
-we have bonds that form a network overlayed on the hierarchy. This is
-illustrated in the picture on the left. An important feature of entities is that
-we can always assume that the hierarchy is intact. You will never find an atom
-without residues, no residue can exist without a parent chain and chains belong
-always to an entity.
-
-Let There Be Shiny Graphics
---------------------------------------------------------------------------------
-
-For visually inspecting the fragment, we now create a graphical representation
-of the entity:
-
- .. code-block:: python
-
- go=gfx.Entity("Fragment", fragment)
- scene.Add(go)
- scene.CenterOn(go)
-
-Now you will see the fragment in the 3D window (left):
-
-
-
-Use the mouse to rotate, zoom in an shift the camera. Double clicking on an atom will center the camera on that atom.
-
-Introduction to Views
---------------------------------------------------------------------------------
-
-Often during processing and visualisation of data, only parts of a protein
-structure are of interest. This realisation has had a major impact on the design
-of OpenStructure and is tied very deeply into the core of the framework.
-Subparts of structure are modeled as so-called :class:`EntityViews
-<mol.EntityView>`. You can think of them as a selection of chains, residues,
-atoms and bonds of an entity. A views has almost the same interface as the
-underlying entity, making it very easy to mix entity views with handles in
-Python due to the dynamic nature of the language. An algorithm that is written
-for entities will almost always (with some care) also work for
-:class:`EntityHandles <mol.EntityHandle>`. This is referred to as `duck-typing
-<http://en.wikipedia.org/wiki/Duck_typing>`_ (I don' t care if it is a duck as
-long as it looks like a duck), a concept used all over the place in Python.
-
-A typical view can be seen in the image on the left. The view consists of one
-chain, one residue and two atoms. Again the same rule applies: No atom can be
-part of the view without it's residue. In this example, no bonds are included,
-since there is at most one atom per bond in the original structure.
-
-To familiarize yourself with the concept of views, we will use the fragment in
-the 3D window.
-
-We will use several ways to select parts of our fragment:
- * By using a dedicated query language
- * By manually constructing a view
-
-The Query Language
---------------------------------------------------------------------------------
-
-The first way to select parts of a structure is with a dedicated mini-language,
-called ["the query language”](docs/tut/query.html). In the Python Shell, type
-
- .. code-block:: python
-
- go.selection=fragment.Select('')
-
-A green halo will be displayed around the selected parts (image in the middle).
-
-As you can see the previous statement created a “full view”, containing all the
-chains, residues, atoms and bonds. To select lysine residues, type
-
- .. code-block:: python
-
- go.selection=fragment.Select('rname=LYS')
-
-
-As you can see (image in the middle), the only lysine residue is now
-highlighted in the 3D window, because it was the only one matching the predicate
-"residue name must be equal to LYS". Several such predicates can be combined
-with boolean operators such as *and* and *or*. To select residues with residue
-number 1 to 3, the following statement will do the job:
-
- .. code-block:: python
-
- go.selection=fragment.Select('rnum>=1 and rnum<=3')
-
-but this is very cumbersome. That's why there is a shortcut to this statement.
-You can specify a range of values.
-
- .. code-block:: python
-
- go.selection=fragment.Select('rnum=1:3')
-
-For a complete description of what you can do with the query language, have a
-look at the :doc:`../mol/base/query`.
-
-
-Constructing Views Manually
---------------------------------------------------------------------------------
-
-Sometimes the query language Is Not Enough (TM). For these cases the
-construction of manual entities becomes neccessary. This is pretty straight
-forward:
-
- .. code-block:: python
-
- view=fragment.CreateEmptyView()
- ca=fragment.FindAtom('A', mol.ResNum(1), 'CA')
- cb=fragment.FindAtom('A', mol.ResNum(1), 'CB')
- view.AddAtom(ca)
- view.AddAtom(cb)
- go.SetSelection(view)
-
-The last step sets our constructed view as the current selection, displaying it
-in the 3D window. As you can see, C-alpha and C-beta of the first residue are
-not connected by bonds, even though both atoms are in the view. You have either
-to add the bond manually with
-
- .. code-block:: python
-
- ca_cb=ca.FindBondToAtom(cb)
- view.AddBond(ca_cb)
-
-Or as a very convenient shortcut 'view.AddAllInclusiveBonds()' to add all bonds
-that have both bonding partners in the view.
-
-Don't forget to call update the selection of the graphics object to see what
-view you have created.
-
-Saving an Entity
---------------------------------------------------------------------------------
-
-Saving an entity (or a view) is a breeze:
-
-Type
-
- .. code-block:: python
-
- io.SavePDB(fragment, 'full.pdb')
-
-to save the full view. To save only the backbone atoms, we can first select the
-backbone atoms and then save it:
-
- .. code-block:: python
-
- io.SavePDB(fragment.Select('aname=CA,C,N,O'), 'backbone.pdb')
-
-
-Loading images and density maps
---------------------------------------------------------------------------------
-
-Openstructure features a :mod:`~ost.img` module that is dedicated to the
-manipulation of
-images/density maps. The images or density maps can either be one-, two- or
-three-dimensional. The most common formats used in x-ray and electron
-crystallography and atomic force microscope are supported in addition to several
-general purpose image formats. See `supported file formats` for details.
-The :mod:`~ost.img` module was originally developed as part of the Image
-Processing Library & Toolbox IPLT. More documentation and examples can also be
-found on the `IPLT website <http://www.iplt.org>`_.
-
-To load a density map, type
-
- .. code-block:: python
-
- map=io.LoadImage('/path/to/examples/map/1ppt.map')
-
-This will load the fragment density map from the specified file 'fragment.map'
-and store the result in fragment_map.
-
-Now let's inspect what we just loaded:
-
- .. code-block:: python
-
- print map.GetPixelSampling()
-
-We can see that the sampling is set to 1.0 Angstroems in all three dimensions.
-
-Manipulating images and density maps
---------------------------------------------------------------------------------
-
-The algorithms used for manipulation of an image are found in the
-:mod:`~ost.img` module. Therefore before using an algorithm we first have to
-import the :mod:`~ost.img` module.
-
- .. code-block:: python
-
- from ost import img
-
-
-The :mod:`~ost.img` module provides a wide range of algorithm to manipulate
-image data. Here for the example we use a LowPassFilter to restrict the
-resolution of the density map.
-
- .. code-block:: python
-
- map_filtered=map.Apply(img.alg.LowPassFilter(3.0))
-
-The filtered map is stored in a new variable called fragment\_map\_filtered.
-
-
-Displaying images and density maps
---------------------------------------------------------------------------------
-
-Now that we have a filtered map it's time to have a look at it. There are
-fundamentally two ways to visualize 3-dimensional density maps. One is by
-drawing isosurfaces. These are conceputally similar to contour lines used in
-cartography: every point on an isosurface has the same density value.
-Isosurfaces are easy to create in OpenStructure:
-
- .. code-block:: python
-
- go=gfx.MapIso("filtered", map_filtered,0.5)
- scene.Add(go)
-
-The other way to visualize a 3-dimensional map is by showing one 2-dimensional
-density slice at a time, allowing the user to move through the slices. In
-OpenStructure this is achieved using a DataViewer docs/tut/imgdataviewer.html).
-A DataViewer showing the filtered map is created using the following command:
-
- .. code-block:: python
-
- gui.CreateDataViewer(map_filtered)
-
-This command displays a panel showing one slice of the density map lying on a
-particular (x,y) plane in the coordinate reference system.
-The 'z' and 'x' keys can be used to move to slices lying at a lower or higher
-coordinate along the 'z' axis, allowing the examination of
-the full 3-dimensional volume.
-
-A more detailed explanation of the :mod:`~ost.img` module can be found in the
-tutorial section for :mod:`~ost.img`.
diff --git a/doc/build/_sources/io/formats.txt b/doc/build/_sources/io/formats.txt
deleted file mode 100644
index ceef7e5f25111f28e50c66a966fdacf6d621bc61..0000000000000000000000000000000000000000
--- a/doc/build/_sources/io/formats.txt
+++ /dev/null
@@ -1,81 +0,0 @@
-Supported File Formats
-================================================================================
-
-Structure File Formats
---------------------------------------------------------------------------------
-
-The following file formats are supported by :func:`~ost.io.LoadEntity`.
-
-
-
-PDB - Brookhaven PDB File
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Fine grained control over PDB file import is available via the
-:func:`~ost.io.LoadPDB` function. The PDB importer support loading gzipped PDB
-files. gzipped PDB files are detected by the .gz file extension.
-
-*Recognized File Extensions*
- ent, pdb, ent.gz, pdb.gz
-
-*Format Name*
- pdb
-
-PQR
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- pqr
-
-*Format Name*
- pqr
-
-CRD - CARD format file used by CHARMM
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- crd
-
-SDF
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- sdf
-
-Sequence File Formats
---------------------------------------------------------------------------------
-
-FASTA
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- fasta, fna, fas, fa, fsa
-
-*Format Name*
- fasta
-
-ClustalW
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- aln
-
-*Format Name*
- clustal
-
-Promod
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- ali
-
-*Format Name*
- promod
-
-PIR
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- pir
-
-*Format Name*
- pir
\ No newline at end of file
diff --git a/doc/build/_sources/io/io.txt b/doc/build/_sources/io/io.txt
deleted file mode 100644
index 21c38bc4f93f2ce10b4357004c9c688f310a178a..0000000000000000000000000000000000000000
--- a/doc/build/_sources/io/io.txt
+++ /dev/null
@@ -1,103 +0,0 @@
-:mod:`~ost.io` - Input and Output of Sequences, Structures and Maps
-================================================================================
-
-.. module:: ost.io
- :synopsis: Input and output of sequences, structures and density maps
-
-The io module deals with input and output of :class:`entities
-<ost.mol.EntityHandle>`, :class:`alignments <ost.seq.AlignmentHandle>`, and
-:class:`images <ost.img.ImageHandle>`. Importers for common file formats such
-as PDB, SDF, FASTA, CLUSTAL W, DX and CHARMM trajectory files are available.
-
-Molecular Structures
---------------------------------------------------------------------------------
-
-Loading Molecular Structures
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The :mod:`~ost.io` modules offers several ways to load molecular structures
-depending on your requirements. The most general way is offered by
-:func:`~ost.io.LoadEntity`, which will automatically detect the file format based
-on the file extension.
-
-.. function:: LoadEntity(filename, format='auto')
-
- Load entity from disk. If format is set to 'auto', the function guesses the
- filetype based on the extension of the file. Files ending in '.pdb', '.ent',
- '.ent.gz', '.pdb.gz' will automatically be loaded as PDB files, for example.
- For files without or exotic extensions, the format can be set explicitly as
- the second parameter.
-
- .. code-block:: python
-
- # recognizes SDF file by file extension
- ent=io.LoadEntity('file.sdf')
-
- # In this case, there is no file extensions, so you have to say it's a
- # SDF file explicitly
- ent=io.LoadEntity('file', 'sdf')
-
- For a list of file formats supported by :func:`LoadEntity`, see :doc:`formats`.
-
- :raises: :exc:`~ost.io.IOUnknownFormatException` if the format string supplied
- is not recognized or the file format can not be detected based on the
- file extension
-
- :exc:`~ost.io.IOException` if the import fails due to an erroneous or
- inexistent file
-
-Some of the formats have a dedicated function that allows you to tweak many
-parameters that affect the import. PDB files can be loaded with
-:func:`~ost.io.LoadPDB`. It offers a tighter control over the exact loading
-behaviour.
-
-.. autofunction:: ost.io.LoadPDB
-
-
-Saving Molecular Structures
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Saving a complete entity or a view is a matter of calling
-:func:`~ost.io.SaveEntity`.
-
-.. code-block:: python
-
- ent=io.LoadEntity('protein.pdb')
- # save full entity
- io.SaveEntity(ent, 'full.pdb')
- # only save C-alpha atoms
- io.SaveEntity(ent.Select('aname=CA and peptide=true'), 'calpha.pdb')
-
-:func:`~ost.io.SavePDB` provides a simple way to save several entities into one
-file:
-
-
-.. code-block:: python
-
- ent=io.LoadEntity('protein.pdb')
- # Save complete entity
- io.SavePDB(ent, 'full.pdb')
- # Save chain A and chain B separately
- io.SavePDB([ent.Select('cname=A'), ent.Select('cname=B')], 'split.pdb')
-
-
-.. function:: SaveEntity(ent, filename, format='auto')
-
- Save entity to disk. If format is set to 'auto', the function guesses the
- filetype based on the file extension, otherwise the supplied format is checked
- against the available export plugins.
-
- :param ent: The entity to be saved
- :type ent: :class:`~ost.mol.EntityHandle` or :class:`~ost.mol.EntityView`
- :param filename: The filename
- :type filename: string
- :param format: Name of the format
- :type format: string
-
- :raises: :exc:`~ost.io.IOUnknownFormatException` if the format string supplied
- is not recognized or the file format can not be detected based on the
- file extension
-
-.. autofunction:: ost.io.SavePDB
-
-
\ No newline at end of file
diff --git a/doc/build/_sources/mol/base/editors.txt b/doc/build/_sources/mol/base/editors.txt
deleted file mode 100644
index f224b2e1fd2290db8be073dda9d18fc36bf052db..0000000000000000000000000000000000000000
--- a/doc/build/_sources/mol/base/editors.txt
+++ /dev/null
@@ -1,151 +0,0 @@
-Editors
-================================================================================
-
-.. currentmodule:: ost.mol
-
-The structure, topology and connectivity of entities is edited via editors. This
-includes operations such as changing atom positions, connecting atoms with bonds
-as well as adding and removing chains, residues and atoms.
-
-Edit Modes
---------------------------------------------------------------------------------
-
-Editors support two modes: An unbuffered edit mode and a buffered edit mode. In
-the unbuffered edit mode, dependent information such as the spatial organizer
-and the internal coordinate system (in case of the XCSEditor) are updated after
-every change. In buffered edit mode, the updates are delayed until one of the
-following happens:
-
- * The last editor goes out of scope.
- * :meth:`XCSEditor.UpdateICS` or :meth:`ICSEditor.UpdateXCS` is called
- explicitly.
-
-
-The editors follow the RIAA (resource allocation is initialisation) principle:
-Whenever an editor is requested an internal reference counter is incremented. In
-the destructor, this reference count is decremented. When the count drops to
-zero, the dependent infomation is updated.
-
-In Python, one can not rely on the destructors being called. It is adviced to
-always put a call to :meth:`XCSEditor.UpdateICS` or
-:meth:`ICSEditor.UpdateXCS` when the editing is finished. Alternatively, starting from Python version 2.6, one can use the
-`with <http://docs.python.org/reference/compound_stmts.html#with>`_ statement
-to make sure the destructor are called and the dependent information is updated.
-
-
-Basic Editing Operations
---------------------------------------------------------------------------------
-
-The basic functionality of editors is implemented in the EditorBase class.
-
-.. class:: EditorBase
-
- Inherited by :class:`XCSEditor`, :class:`ICSEditor`.
-
- .. method:: InsertChain(chain_name)
-
- Add new chain to the entity
-
- :param chain_name: The chain's name. In the scope of an entity, chain names
- are unique. If a chain of the same already exists an
- IntegrityError is raised.
- :type chain_name: string
- :returns: :class:`ChainHandle`
-
- .. method:: AppendResidue(chain, residue_name, [res_num])
-
- Append residue to the end of the chain. If res_num is not given, the
- residue number will be set to the residue number of the last added residue
- plus one. The insertion code is the same.
-
- :param chain: Must be a valid chain
- :type chain: :class:`ChainHandle`
- :param residue_name: 3-letter-code of the residue, e.g. ``GLY``.
- :type residue_name: string
- :returns: :class:`ResidueHandle`
-
- .. method:: InsertAtom(residue, atom_name, pos, [prop=mol.AtomProp()])
-
- Insert new atom and add it to residue. For atoms with alternative atom
- locations use :meth:`InsertAltAtom`.
-
- :param residue: is the parent residue and must be valid
- :type residue: :class:`ResidueHandle`
- :param atom_name: is the atom name. While free to choose a name, it is
- adviced to properly name the atoms according to IUPAC
- rules as several algorithms as well as most
- :class:`builders <conop.Builder>` in the :mod:`conop`
- module rely on proper naming.
- :type atom_name: string
- :param pos: is the position of the atom in global coordinates
- :type pos: :class:`geom.Vec3`
- :param prop: are the atom's properties such as element, van der Waals
- radius charge and so on. The default set of atom
- properties is rather meaningless.
- :type prop: class:`AtomProp`
- :returns: :class:`AtomHandle`
-
-Editor for the External Coordinate System
---------------------------------------------------------------------------------
-
-The XCSEditor defines the interface for manipulating the external coordinate
-system. The external coordinate system directly operates on atom positions in
-euclidian space.
-
-.. class:: XCSEditor
-
- Inherits :class:`EditorBase`
-
- .. method:: ApplyTransform(transform)
-
- Apply a transformation the entity transform. The entity transform is a
- global transformation applied to all atoms.
-
- :param transform: The transformation to be applied
- :type transform: :class:`geom.Mat4`
-
- .. method:: SetTransform(transform)
-
- Set the entity transformation. See also :meth:`ApplyTransform`
-
- :param transform: The transformation to be applied
- :type transform: :class:`geom.Mat4`
-
- .. method:: SetAtomPos(atom, pos)
-
- Set the (transformed) position of atom. This method will also update the
- original position of the atom by applying the inverse of the entity
- transform.
-
- :param atom: must be a valid atom handle
- :type atom: :class:`ost.mol.AtomHandle`
- :param pos: The new position
- :type pos: :class:`geom.Vec3`
-
- .. method:: SetOriginalAtomPos(atom, pos)
-
- Set the origininal (untransformed) position of the atom. This method will
- also update the transformed position by applying the entity transform to
- the original pos.
-
- :param atom: must be a valid atom handle
- :type atom: :class:`ost.mol.AtomHandle`
- :param pos: The new untransformed position
- :type pos: :class:`geom.Vec3`
-
-Editor for the Internal Coordinate System
---------------------------------------------------------------------------------
-The :class:`ICSEditor` is used to manipulate the internal coordinate system that
-is defined by bond lengths and angles. By default the internal coordinate system
-is not calculates. However, upon requesting an :class:`ICSEditor` for the first
-time, the internal coordinate system is initialized. This involves the build-up
-of a directed-graph for the bond network as well as calculating the internal
-coordinate matrices.
-
-The use :class:`XCSEditor` and :class:`ICSEditor` are mutually exclusive. This
-means that whenever a :class:`XCSEditor` has pending changes, the results of
-using an :class:`ICSEditor` is undefined and vice versa.
-
-.. class:: ICSEditor
-
- Inherits :class:`EditorBase`
diff --git a/doc/build/_sources/mol/base/entity.txt b/doc/build/_sources/mol/base/entity.txt
deleted file mode 100644
index 1adcd2de76af8d919b0928bc91b01669912a1a59..0000000000000000000000000000000000000000
--- a/doc/build/_sources/mol/base/entity.txt
+++ /dev/null
@@ -1,332 +0,0 @@
-The Molecular Entity
-================================================================================
-
-.. currentmodule:: ost.mol
-
-This document describes the :class:`EntityHandle` and related classes.
-
-
-.. function:: CreateEntity()
-
- Creates a new entity. The created entity is empty, that is, it does not
- contain any atoms, residues, chains, bonds or torsions. To populate the
- entity, use an :doc:`editors`.
-
- :returns: The newly created :class:`EntityHandle`
-
-.. class:: EntityHandle
-
- The entity class represents a molecular structure. Such a structure is in
- general made up of one or more linear chains of residues, which in turn are
- formed by one or more atoms.
-
- The interface of entities is tailored to biological macromolecules, but this
- does not prevent it to be used for molecules in general: An entity also
- represent a ligand or a collection of water molecules - hence the rather
- generic name.
-
- .. method:: FindChain(chain_name)
-
- Get chain by name. See also :meth:`GetChainList`
-
- :param chain_name: Chain identifier, e.g. "A"
- :type chain_name: string
- :returns: A valid :class:`ChainHandle`, if the entity contains a
- chain with the given name, an invalid
- :class:`ChainHandle` otherwise.
-
- .. method:: GetChainList()
-
- Get list of all chains of this entity. To access a single chain, use
- :meth:`FindChain`.
-
- :returns: A list of :class:`ChainHandles<ChainHandle>`
-
- .. method:: FindResidue(chain_name, res_num)
-
- Get residue by chain name and residue number. See also
- :meth:`GetResidueList`
-
- :param chain_name: Chain identifier, e.g. "A"
- :type chain_name: string
- :param res_num: residue number
- :type res_num: mol.ResNum
-
- :returns: A valid :class:`ResidueHandle` if the chain exists and
- the chain contains a residue of the given residue
- number, an invalid :class:`ResidueHandle` otherwise.
-
- .. method:: GetResidueList()
-
- Get list of all residues of this entity. To access a single residue, use
- :meth:`FindResidue`.
-
- :returns: A list of :class:`ResidueHandles<ResidueHandle>`
-
- .. method:: FindAtom(chain_name, res_num, atom_name)
-
- Get atom by chain name, residue number and atom name. See also
- :meth:`GetAtomList`
-
- :param chain_name: Chain identifier, e.g. "A"
- :type chain_name: string
- :param res_num: residue number
- :type res_num: mol.ResNum
- :param atom_name: atom name, e.g. CA
- :type atom_name: string
-
- :returns: A valid :class:`AtomHandle` if an atom matching the
- parameters could be found, an invalid
- :class:`AtomHandle` otherwise
-
- .. method:: GetAtomList()
-
- Get list of all atoms of this entity. To access a single atom, use
- :meth:`FindAtom`
-
- :returns: A list of :class:`AtomHandles<AtomHandle>`
-
- .. method:: RequestXCSEditor([edit_mode=mol.EditMode.BUFFERED_EDIT])
-
- Request :class:`XCSEditor` for editing the external coordinate system. This
- call will fail when there are pending changes of the internal coordinate
- system.
-
- :param edit_mode: Must be EditMode.BUFFERED_EDIT or
- EditMode.UNBUFFERED_EDIT. For more details, see the
- editor documentation.
- :type edit_mode: mol.EditMode
-
- :returns: :class:`XCSEditor`
- .. method:: RequestICSEditor([edit_mode=mol.EditMode.BUFFERED_EDIT])
-
- Request :class:`ICSEditor` for editing the internal coordinate system, such
- as torsions, bond lengths and angle between two bonds. This call will fail
- when there are pending changes of the external coordinate system.
-
- :param edit_mode: Must be EditMode.BUFFERED_EDIT or
- EditMode.UNBUFFERED_EDIT. For more details, see the
- editor documentation.
- :type edit_mode: mol.EditMode
-
- :returns: :class:`ICSEditor`
-
- .. method:: Select(query, flags)
-
- Perform a selection on the entity. The result of the selection is an
- :class:`EntityView` which contains usually only a subset of chains,
- residues, atoms and bonds of the original entity.
-
- :param query: The query to be executed. See :class:`Query` for details.
- :type query: string or :class:`Query`
- :param flags: An ORed combination of :class:`QueryFlags`.
- :type flags: int
- :returns: An :class:`entity view <EntityView>`.
- :raises: :class:`QueryError` when the query could not be executed due
- to syntactic errors.
-
- .. method:: CreateFullView()
-
- Creates an entity view containing all chains, residues, atoms and bonds of
- this entity.
-
- .. code-block:: python
-
- # these two lines are identical
- full=ent.Select('')
- full=ent.CreateFullView()
-
- :returns: :class:`EntityView`
-
- .. method:: CreateEmptyView()
-
- Creates an entity view pointing to this entity, but otherwise empty. This
- method is usually the starting point for manual entity view creation, e.g.
-
- .. code-block:: python
-
- view=ent.CreateEmtpyView()
- for atom in ent.atoms:
- if ComplicatedPredicate(atom):
- view.AddAtom(atom)
-
- :returns: :class:`EntityView`
-
- .. method:: Copy()
-
- Creates a deep copy of the entity.
-
- :returns: A new :class:`EntityHandle` that is an exact copy of this entity.
-
- .. note::
-
- alternative atom positions are not handled yet.
-
- .. method:: GetCenterOfAtoms()
-
- Get center of atoms, that is the average atom position of the entity. Use
- :meth:`GetCenterOfMass` to calculate the mass-weighted center of the entity.
-
- :returns: :class:`geom.Vec3`
-
- .. method:: GetCenterOfMass()
-
- Calculates the center of mass of the entity. Use :meth:`GetCenterOfAtoms`
- to calculate the non-mass-weighted center of the entity.
-
- :returns: :class:`geom.Vec3`
-
- .. method:: GetGeometricCenter()
-
- Calculates the mid-point of the axis aligned bounding box of the entity.
-
- :returns: :class:`geom.Vec3`
-
- .. method:: GetMass()
-
- Calculates the total mass of the entity by summing up the masses of all
- atoms.
-
- :returns: The mass in Dalton
-
- .. method:: Apply(visitor)
-
- Apply EntityVisitor to the entity. In Python, you shouldn't bother using
- this function. EntityVisitory are mainly used in C++ to implement
- algorithms that operate are able to operate on EntityViews or
- EntityHandles.
-
- .. method:: FindWithin(pos, radius)
-
- Find all atoms in sphere of given radius centered at *pos*. To turn the
- returned list of atoms into an :class:`EntityView`, use
- :func:`CreateViewFromAtomList`.
-
- :param pos: Center of sphere
- :type pos: :class:`geom.Vec3`
- :param radius: The radius of the sphere
- :type radius: float
-
- :returns: A list of :class:`AtomHandles<AtomHandle>`
-
-.. class:: ChainHandle
-
- .. method:: FindResidue(res_num)
-
- Get residue by residue number. See also :meth:`GetResidueList`
-
- :param res_num: residue number
- :type res_num: mol.ResNum
-
- :returns: A valid :class:`ResidueHandle` if the chain contains
- a residue with matching residue number, an invalid
- :class:`ResidueHandle` otherwise.
-
- .. method:: GetResidueList()
-
- Get list of all residues of this chain. For peptide chains, the residues
- are usually ordered from N- to C-terminus.To access a single residue, use
- :meth:`FindResidue`.
-
- :returns: A list of :class:`ResidueHandles<ResidueHandle>`
-
- .. method:: FindAtom(res_num, atom_name)
-
- Get atom by residue number and atom name. See also :meth:`GetAtomList`
-
- :param res_num: residue number
- :type res_num: mol.ResNum
- :param atom_name: atom name, e.g. CA
- :type atom_name: string
-
- :returns: A valid :class:`AtomHandle` if an atom matching the
- parameters could be found, an invalid
- :class:`AtomHandle` otherwise
-
- .. method:: GetAtomList()
-
- Get list of all atoms of this chain. To access a single atom, use
- :meth:`FindAtom`
-
- :returns: A list of :class:`AtomHandles<AtomHandle>`
-
-.. class:: ResidueHandle
-
- .. method:: FindAtom(atom_name)
-
- Get atom by atom name. See also :meth:`GetAtomList`
-
- :param atom_name: atom name, e.g. CA
- :type atom_name: string
-
- :returns: A valid :class:`AtomHandle` if an atom with the given
- name could be found, an invalid :class:`AtomHandle`
- otherwise
-
- .. method:: GetAtomList()
-
- Get list of all atoms of this residue. To access a single atom, use
- :meth:`FindAtom`.
-
-.. class:: AtomHandle
-
-.. class:: EntityView
-
- Represents a subpart of an :class:`EntityHandle`.
-
-Functions
---------------------------------------------------------------------------------
-
-
-Boolean Operators
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. function:: Intersection(view_a, view_b)
-
- Calculates and returns the intersection of `view_a` and `view_b`. `view_a`
- and `view_b` must be views of the same entity.
-
- :param view_a: first view
- :type view_a: EntityView
- :param view_b: second view
- :type view_b: EntityView
-
-.. function:: Difference(view_a, view_b)
-
- Calculates and returns the difference between `view_a` and `view_b`. `view_a`
- and `view_b` must be views of the same entity.The returned view will
- contain atoms, residues, chains and bonds that are in `view_a` and not in
- `view_b`.
-
- :param view_a: first view
- :type view_a: EntityView
- :param view_b: second view
- :type view_b: EntityView
-
-.. function:: Union(view_a, view_b)
-
- Calculates and returns the union of `view_a` and `view_b`. `view_a`
- and `view_b` must be views of the same entity.The returned view will contain
- all atoms, residues, chains and bonds that are either in `view_a`, `view_b`
- or part of both views.
-
- :param view_a: first view
- :type view_a: EntityView
- :param view_b: second view
- :type view_b: EntityView
-
-
-Other Entity-Related Functions
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. function:: CreateViewFromAtomList(atom_list)
-
- Returns a view made up of the atoms in *atom_list*. All atoms are required to
- be atoms of the same entity. Duplicate atoms are only added to the view once.
-
- :param atom_list: the atoms
- :type atom_list: :class:`AtomHandleList` or :class:`AtomViewList`
- :raises: :class:`IntegrityError` if atoms of different entities are
- encountered
-
- :returns: :class:`EntityView`
\ No newline at end of file
diff --git a/doc/build/_sources/mol/base/mol.txt b/doc/build/_sources/mol/base/mol.txt
deleted file mode 100644
index a16b21f541edbec24a14ea8f96c9183adc9cf4f3..0000000000000000000000000000000000000000
--- a/doc/build/_sources/mol/base/mol.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-:mod:`~ost.mol` -- Molecular structures and surfaces
-================================================================================
-
-.. module:: ost.mol
- :synopsis: Contains classes and functions to deal with molecular structures
- and surfaces
-
-The mol module implement data structure to work with molecular datasets. At its heart lie the :class:`EntityHandle` and :class:`EntityView` classes which represent molecular structures such as proteins, DNA, RNA and small molecules. There are also classes to deal with molecular surfaces.
-
-.. toctree::
-
- entity
- editors
- query
\ No newline at end of file
diff --git a/doc/build/_sources/mol/base/query.txt b/doc/build/_sources/mol/base/query.txt
deleted file mode 100644
index 20c4b711a2a0e9c190efce278af82df16ac84ee1..0000000000000000000000000000000000000000
--- a/doc/build/_sources/mol/base/query.txt
+++ /dev/null
@@ -1,124 +0,0 @@
-Queries
-================================================================================
-
-.. class:: Query
-
- Blabla
-
-It is often convenient to highlight or focus certain parts of the structure.
-OpenStructure includes a powerful query system that allows you to perform custom
-selections in a convenient way.
-
-Please refer to the tutorial on the query language for an introduction.
-
-The query language reference
---------------------------------------------------------------------------------
-
-The query consists of one or more predicates combined with boolean
-operators. A predicate takes the form *prop op value*. Operators are
-one of `` =, !=, >, >=, <=`` and ``<``. A predicate has the following form:
-*PROPERTY - OPERATOR - ARGUMENT*.
-
-The following properties may be used in predicates. The supported type of the
-value is given for each property.
-
- * ``rname`` residue name. type: string
- * ``rnum`` residue number. currently only numeric part is honored.
- type: int
- * ``rtype`` residue type as given by the DSSP code, i.e. H for helix, E
- for extended. type: string
- * ``aname`` atom name. type: string
- * ``ele`` element of atom. type: string
- * ``cname`` chain name. type: string
- * ``occ`` occupancy, between 0 and 1. type: float
- * ``abfac`` B (temperature) factor of atom. type: float
- * ``rbfac`` average B (temperature) factor of residue. type: float.
- Note that this does not work for views as expected. When running a
- second selection statement on a view, all atoms of the residue handle
- and not the view are considered in the calculation
- * ``ishetatm`` whether the atom is a hetorogenous atom. type: bool or int
- (0 for false, 1 for true)
- * ``peptide`` whether the residue is peptide linking. type: bool or int
- (0 for false, 1 for true)
- * ``x`` X coordinate of atom. type: float
- * ``y`` Y coordinate of atom. type: float
- * ``z`` Z coordinate of atom. type: float
- * ``rindex`` index of residue in chain. This index is the same for views
- and handles
- * For :ref:`generic properties in queries <genprop-in-queries>` see below.
-
-Distance-based selections within a given atom position are supported by
-the within statement. To select atoms within 5 Angstrom of the point
-``{1, 2, 3}``, one would write:
-
-``5 <> {1,2,3}``
-
-Negation of this expression is possible with the not operator, i.e.
-
-``not 5 <> {1,2,3}``
-will select atoms that are further than five Angstrom apart from ``{1, 2 , 3}``
-
-Abbreviations
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Two abbreviations exist for convenience:
-
-Instead of writing
-
-``aname=CA or aname=C or aname=O or aname=N``,
-
-one can write
-
-``aname=CA,N,C,O``.
-
-For integral value ranges, one can use the colon syntax: instead of
-
-``rnum>=10 and rnum<=20``
-
-one can write
-
-``rnum=10:20``
-
-.. _genprop-in-queries:
-
-Generic Properties in Queries
---------------------------------------------------------------------------------
-
-The query language can also be used for numeric generic properties (i.e.
-float and int), but the syntax is slightly different. To access any generic
-properties, it needs to be specified that they are generic and at which level
-they are defined. Therefore, all generic properties start with a ``g``, followed by an ``a``, ``r`` or ``c`` for atom, residue or chain level respectively.
-
-.. code-block:: python
-
- # set generic properties for atom, residue, chain
- atom_handle.SetFloatProp("testpropatom", 5.2)
- resid_handle.SetFloatProp("testpropres", 1.1)
- chain_handle.SetIntProp("testpropchain", 10)
-
- # query statements
- sel_a=e.Select("gatestpropatom<=10.0")
- sel_r=e.Select("grtestpropres=1.0")
- sel_c=e.Select("gctestpropchain>5")
-
-Since generic properties do not need to be defined for all parts of an entity
-(e.g. it could be specified for one single :class:`AtomHandle`), the query
-statement will throw an error unless you specify a default value in the query
-statement which can be done using a ':' character:
-
-.. code-block:: python
-
- # if one or more atoms have no generic properties
-
- sel=e.Select("gatestprop=5")
- # this will throw an error
-
- # you can specify a default value:
- sel=e.Select("gatestprop:1.0=5")
- # this will run through smoothly and use 1.0 as
- # the default value for all atoms that do not
- # have the generic property 'testprop'
-
-Using this method, you will be warned if a generic property is not set for all
-atoms, residues or chains unless you specify a default value. So, be careful
-when you do.
diff --git a/doc/build/_sources/newmodule.txt b/doc/build/_sources/newmodule.txt
deleted file mode 100644
index a45283055f5a4e60af1f468b5846857d7c3c28c1..0000000000000000000000000000000000000000
--- a/doc/build/_sources/newmodule.txt
+++ /dev/null
@@ -1,301 +0,0 @@
-Creating a New Module
-================================================================================
-
-OpenStructure can be extended by writing additional modules. A module will
-usually consist of a set of C++ classes and methods, most of which will also be
-exported to Python. It is also possible to write modules completely in Python.
-
-The build system of OpenStructure is quite simple. The main difference to other
-projects is the use of a so-called stage directory. The stage directory
-replicates the normal layout of a standard Linux directory structure, with an
-'include' directory for the headers, a 'lib' directory containing the shared
-library files, a `bin` directory for the executables and a 'share' directory
-for the platform-independent data like icons, images and examples.
-
-OpenStructure uses `CMake <http://www.cmake.org>`_ to build the project. The
-rules for the build-system are defined in `CMakeLists.txt` files. When running
-`CMake <http://cmake.org>`_, the files are compiled and copied into stage. The
-real installation, if necessary, happens at a later stage. This is referred to
-as staging of the files.
-
-If a new module is written following the guidelines in this page, it will be
-seamlessly included in the build system and will then be available form both
-the DNG python console and the OpenStructure command line as any other native
-module.
-
-As a first step, a new directory structure must be created to accommodate the
-new module.
-
-Directory Structure
---------------------------------------------------------------------------------
-
-For the purpose of this example, let's assume we are creating a new module
-called 'mod' (for 'modeling'). Let's create a directory named `mod` under the
-'modules' directory in the OpenStructure development tree, and populate it with
-the three subdirectories `src`, `pymod`, and `tests`. Then we add a
-`CMakeLists.txt` file in the 'mod' directory, consisting of three lines:
-
-.. code-block:: bash
-
- add_subdirectory(src)
- add_subdirectory(pymod)
- add_subdirectory(tests)
-
-The Module Code
---------------------------------------------------------------------------------
-
-In the `src` subdirectory we put the code that implements the functionality of
-the new module, plus a `config.hh` header file.
-
-Here is a skeleton of one of the files in the directory , `modeling_new_class.hh`:
-
-.. code-block:: cpp
-
- #ifndef OST_MOD_NEW_CLASS_H
- #define OST_MOD_NEW_CLASS_H
-
- #include <ost/mod/module_config.hh>
-
- // All other necessary includes go here
-
- namespace ost { namespace mod {
-
- class DLLEXPORT_OST_MOD NewClass {
- public:
- void NewMethod();
-
- // All declarations of NewClass go here
-
- };
-
- }} // namespaces
-
- #endif
-
-And here is the skeleton of the corresponding `modeling_new_class.cc` file:
-
-.. code-block:: cpp
-
- #include "modeling_new_class.hh"
-
- using namespace ost::mol;
- using namespace ost::mod;
-
- // All other necessary includes and namespace directives
- // go here
-
- void NewClass::NewMethod():
- {
- // Implementation
- }
-
- // Implementation code for NewClass goes here
-
-Obviously, the `src` directory can contain many files, each implementing classes
-and functions that will end up in the module. In order to build and stage
-the module shared library, a `CMakeLists.txt` file needs to be written for the
-`src` directory:
-
-.. code-block:: bash
-
- set(OST_MOD_SOURCES
- modeling_new_class.cc
- // All other source files
- )
-
- set(OST_MOD_HEADERS
- modeling_new_class.hh
- // All other header files
- )
-
- module(NAME mod SOURCES "${OST_MOD_SOURCES}"
- HEADERS ${OST_MOD_HEADERS}
- DEPENDS_ON mol mol_alg)
-
-
-The line containing the `DEPENDS_ON` directive lists all the modules on which
-the new module depends (in this case :mod:`mol` and :mod:`ost.mol.alg`). The
-`module` macro will take care of staging the headers, in this case into
-`ost/mod` and compiling, linking and staging of a library with the name
-`libost_mod.so` (`libost_gmod.dylib` on MacOS X).
-
-.. note::
-
- Due to a limitation in the built-int install command of CMake, for modules
- that have their headers in several directories, it is required to group the
- headers by directory, leading to a call of module like:
-
-.. code-block:: bash
-
- module(NAME mol SOURCES atom_handle.cc impl/atom_impl.cc
- HEADERS atom_impl.hh IN_DIR impl
- atom_handle.hh)
-
-The `module_config.hh` header is required for each module to setup the
-environment on Windows: Each public class, method and function needs to marked
-with `DLLEXPORT` or `DLLIMPORT` to teach the linker where to look for the
-symbol. The correct use of either `DLLIMPORT` and `DLLEXPORT` is depending on
-the context: While compiling a header file that is part of the same shared
-library, `DLLEXPORT` must be used. When compiling a header that is part of
-an external shared library, `DLLIMPORT` must be used. A typical module_config
-header looks like this:
-
-.. code-block:: cpp
-
- #ifndef OST_MOD_MODULE_CONFIG_HH
- #define OST_MOD_MODULE_CONFIG_HH
-
- #include <ost/base.hh>
-
- #if defined(OST_MODULE_OST_MOD)
- # define DLLEXPORT_OST_MOD DLLEXPORT
- #else
- # define DLLEXPORT_OST_MOD DLLIMPORT
- #endif
- #endif
-
-The Testing Framework
---------------------------------------------------------------------------------
-
-The `tests` directory contains code for unit tests. The code is compiled and
-executed when one invokes compilation using the 'make check' command. Tests are
-run by means of the `Boost Unitests Library
-<http://www.boost.org/doc/libs/1_37_0/libs/test/doc/html/index.html>`_, which is
-used throughout OpenStructure. Before coding the test routines, the required
-skeleton needs to be put in place.
-
-The main code is put into 'tests.cc', which will become the test executable:
-
-.. code-block:: cpp
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- #include "test_modeling.hh"
-
- test_suite*
- unit_unit_test_suite( int argc, char * argv[] ) {
- std::auto_ptr<test_suite> test(BOOST_TEST_SUITE( "Module Mod Test" ));
-
- test->add(CreateModelingTest());
-
- return test.release();
- }
-
-
-The most relevant line adds the test suite for the new module to the global test
-list. The test suite is created by the factory function CreateModelingTest(),
-which is declared in the `test_modeling.hh` header file.
-
-.. code-block:: cpp
-
- #ifndef OST_MOD_TEST_MODELING_H
- #define OST_MOD_TEST_MODELING_H
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- test_suite* CreateModelingTest();
-
- #endif
-
-The definition of the factory function is found in the actual test code,
-which we put in `test_modeling.cc`. Here is a skeleton version of that file:
-
-.. code-block:: cpp
-
- #include "test_modeling.hh"
-
- // additional include statements will go here
-
- namespace test_modeling {
-
- void test()
- {
- // test code will go here
- }
-
- }
-
- test_suite* CreateModelingTest()
- {
- using namespace test_modeling;
- test_suite* ts=BOOST_TEST_SUITE("Modeling Test");
- ts->add(BOOST_TEST_CASE(&test));
-
- return ts;
- }
-
-In this file, all the normal Boost Test Library macros and functions can be used. (For example `BOOST_CHECK`, `BOOST_FAIL`, etc.)
-
-Here is finally the build script skeleton that needs to be put into
-`mod/tests/`:
-
-.. code-block:: bash
-
- set(OST_MOD_UNIT_TESTS
- tests.cc
- test_modeling.cc
- )
-
- ost_unittest(mod "${OST_MOD_UNIT_TESTS}")
- target_link_libraries(ost_mol ost_mol_alg ost_mod)
-
-In the last line the call to the 'target\_link\_libraries' function contains the
-names of the modules on which the 'mod' unit test code depends (in this case,
-the :mod:`mol` and :mod:`ost.mol.alg` modules), in addition to the `mod` module
-itself.
-
-The Python Wrapper
---------------------------------------------------------------------------------
-
-Finally, the module API is exported to Python using the `Boost Python
-Library <http://www.boost.org/doc/libs/1_37_0/libs/python/doc/index.html>`_.
-In `mod/pymod`, the wrapper code for the classes in the new module is put into a
-file named `wrap\_mod.cc`:
-
-.. code-block:: cpp
-
- #include <boost/python.hpp>
- using namespace boost::python;
-
- #include <ost/mod/modeling_new_class.hh>
-
- using namespace ost::mol;
- using namespace ost::mod;
-
- // All other necessary includes and namespace directives
- // go here
-
- BOOST_PYTHON_MODULE(_mod)
- {
- class_<NewClass>("NewClass", init<>() )
- .def("NewMethod", &NewClass::NewMethod)
- ;
-
- // All other Boost Python code goes here
- }
-
-The `mod/pymod` directory must obviously contain a `CMakeLists.txt` file:
-
-.. code-block:: bash
-
- set(OST_MOD_PYMOD_SOURCES
- wrap_mod.cc
- )
-
- pymod(NAME mod OUTPUT_DIR ost/mod
- CPP ${OST_MOD_PYMOD_SOURCES} PY __init__.py)
-
-The directory should also contain an `__init.py__` file with the
-following content:
-
-.. code-block:: python
-
- from _mod import *
-
-In case one wants to implement Python-only functionality for the new module, any
-number of function definitions can be added to the `__init.py__` file.
-
-That's it!. The next time the OpenStructure project is compiled, the new module
-will be built and made available at both the C++ and the Python level.
diff --git a/doc/build/_sources/seq/base/seq.txt b/doc/build/_sources/seq/base/seq.txt
deleted file mode 100644
index 7deafe22e797a6d0c4f1ab22cc041f56e5889cbc..0000000000000000000000000000000000000000
--- a/doc/build/_sources/seq/base/seq.txt
+++ /dev/null
@@ -1,350 +0,0 @@
-:mod:`~ost.seq` -- Sequences and Alignments
-================================================================================
-
-.. module:: ost.seq
- :synopsis: Contains classes and functions to deal with sequences and
- alignments
-
-The :mod:`seq` module helps you working with sequence data of various kinds. It
-has classes for :class:`single sequences <SequenceHandle>`, :class:`lists of
-sequences <SequenceList>` and :class:`alignments <AlignmentHandle>` of two or
-more sequences.
-
-
-.. _attaching-views:
-
-Attaching Structures to Sequences
---------------------------------------------------------------------------------
-
-
-Being a structural biology framework, it is not surprising that the sequence
-classes have been designed to work together with structural data. Each sequence
-can have an attached :class:`~mol.EntityView` allowing for fast mapping between
-residues in the entity view and position in the sequence.
-
-.. _sequence-offset:
-
-Sequence Offset
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-When using sequences and structures together, often the start of the structure
-and the beginning of the sequence do not fall together. In the following case,
-the alignment of sequences B and C only covers a subpart of structure A::
-
- A acefghiklmnpqrstuvwy
- B ghiklm
- C 123-45
-
-We would now like to know which residue in protein A is aligned to which residue
-in sequence C. This is achieved by setting the sequence offset of sequence C to
-4. In essence, the sequence offset influences all the mapping operations from
-position in the sequence to residue index and vice versa. By default, the
-sequence offset is 0.
-
-Loading and Saving Sequences and Alignments
---------------------------------------------------------------------------------
-
-The :mod:`io` module supports input and output of common sequence formats.
-Single sequences can be loaded from disk with :func:`io.LoadSequence`,
-alignments are loaded with :func:`io.LoadAlignment` and lists of sequences are loaded with :func:`io.LoadSequenceList`. In addition to the file based input
-methods, sequences can also be loaded from a string:
-
-.. code-block:: python
-
- seq_string='''>sequence
- abcdefghiklmnop'''
- s=io.LoadSequenceFromString(seq_string, 'fasta')
- print s.name, s # will print "sequence abcdefghiklmnop"
-
-Note that, in that case specifying the format is mandatory.
-
-The SequenceHandle
---------------------------------------------------------------------------------
-
-.. function:: CreateSequence(name, sequence)
-
- Create a new :class:`SequenceHandle` with the given name and sequence.
-
- :param name: name of the sequence
- :type name: str
- :param sequence: String of characters representing the sequence. Only
- alphanumerical characters and '-' are allowed.
- :type sequence: str
- :raises InvalidSequence: When the sequence string contains forbidden
- characters, that is anything that is not alphanumeric or a hyphen.
-
-.. class:: SequenceHandle
-
- Represents a sequence. New instances are created with :func:`CreateSequence`.
-
- .. method:: GetPos(residue_index)
-
- Get position of residue with index in sequence. This is best illustrated in
- the following example:
-
- .. code-block:: python
-
- s=seq.CreateSequence("A", "abc---def")
- print s.GetPos(1) # prints 1
- print s.GetPos(3) # prints 6
-
- The reverse mapping, that is from position in the sequence to residue index
- can be achieved with :meth:`GetResidueIndex`.
-
- .. method:: GetResidueIndex(pos)
-
- Get residue index of character at given position. This method is the
- inverse of :meth:`GetPos`. If the sequence contains a gap at that position,
- an :exc:`Error` is raised.
-
- .. code-block:: python
-
- s=seq.CreateSequence("A", "abc--def")
- print s.GetResidueIndex(1) # prints 1
- print s.GetResidueIndex(6) # prints 4
- # the following line raises an exception of type
- # Error with the message "requested position contains
- # a gap"
- print s.GetResidueIndex(3)
-
- .. method:: GetLastNonGap()
-
- Get position of last non-gap character in sequence. In case of an empty
- sequence, or, a sequence only consisting of hyphens, -1 is returned
-
- .. method:: GetFirstNonGap()
-
- Get position of first non-gap character in sequence. In case of an empty
- sequence, or, a sequence only consisting of hyphens, -1 is returned.
-
- .. method:: AttachView(view)
- AttachView(view, [chain_name])
-
- Attach an :class:`~mol.EntityView` to sequence. The first signature requires
- that the view contains one chain. If not, an :exc:`IntegrityError` is
- raised. The second signature will select the chain with the given name. If
- no such chain exists, an :exc:`IntegrityError` is raised.
-
- .. method:: HasAttachedView()
-
- Returns True when the sequence has a view attached, False if not.
-
- .. method:: GetAttachedView()
-
- Returns the attached :class:`~mol.EntityView`, or an invalid
- :class:`~mol.EntityView` if no view has been attached. Also available as
- the property :attr:`attached_view`.
-
- .. method:: GetName()
-
- Returns the name of the sequence. Also available as the property
- :attr:`name`
-
- .. method:: SetSequenceOffset()
-
- Set the :ref:`sequence offset <sequence-offset>`. By default, the offset is
- 0. Also available as the property :attr:`sequence_offset`.
-
- .. method:: GetSequenceOffset()
-
- Returns the :ref:`sequence offset <sequence-offset>`. Also available as
- :attr:`sequence_offset`.
-
-
- .. method:: GetGaplessString()
-
- Returns a string version of this sequence with all hyphens removed. Also
- available as the property :attr:`gapless_string`.
-
-
- .. method:: SetName()
-
- Set name of the sequence. Also available as the property :attr:`name`.
-
- .. attribute:: gapless_string
-
- Shorthand for :meth:`GetGaplessString()`
-
- .. attribute:: name
-
- Shorthand for :meth:`GetName`/:meth:`SetName`
-
- .. attribute:: attached_view
-
- Shorthand for :meth:`GetAttachedView`.
-
- .. attribute:: sequence_offset
-
- Shorthand for :meth:`GetSequenceOffset`/:meth:`SetSequenceOffset`
-
- .. method:: __len__()
-
- Returns the length of the sequence (including insertions and deletions)
-
- .. method:: __str__()
-
- Returns the sequence as a string.
-
-
-The SequenceList
---------------------------------------------------------------------------------
-
-.. class:: SequenceList
-
- Represents a list of sequences. The class provides a row-based interface. New
- instances are created with :func:`CreateSequenceList`.
-
-
-The AlignmentHandle
---------------------------------------------------------------------------------
-
-The :class:`AlignmentHandle` represents a list of aligned sequences. In
-constrast to :class:`SequenceList`, an alignment requires all sequences to be of
-the same length. New instances of alignments are created with
-:func:`CreateAlignment` and :func:`AlignmentFromSequenceList`.
-
-Typically sequence alignments are used column-based, i.e by looking at an
-aligned columns in the sequence alignment. To get a row-based (sequence) view
-on the sequence list, use :meth:`GetSequenceList()`.
-
-All functions that operate on an alignment will again produce a valid alignment.
-This mean that it is not possible to change the length of one sequence, without
-adjusting the other sequences, too.
-
-The following example shows how to iterate over the columns and sequences of
-an alignment:
-
-.. code-block:: python
-
- aln=io.LoadAlignment('aln.fasta')
- # iterate over the columns
- for col in aln:
- print col
-
- # iterate over the sequences
- for s in aln.sequences:
- print s
-
-.. function:: CreateAlignment()
-
- Creates and returns a new :class:`AlignmentHandle` with no sequences.
-
-.. function:: AlignmentFromSequenceList(sequences)
-
- Create a new alignment from the given list of sequences
-
- :param sequences: the list of sequences
- :type sequences: :class:`ConstSequenceList`
-
- :raises: :exc:`InvalidAlignment` if the sequences do not have the same length.
-
-.. class:: AlignmentHandle
-
- .. note::
-
- Several of these methods just forward calls to the sequence. For more
- detailed information, have a look at the :class:`SequenceHandle`
- documentation.
-
- .. method:: GetSequence(index)
-
- Returns the sequence at the given index, raising an IndexError when trying
- to access an inexistent sequence.
-
- .. method:: GetSequenceList()
-
- Returns a list of all sequence of the alignment.
-
- .. method:: GetLength()
-
- Returns the length of the alignment.
-
- .. method:: GetCount()
-
- Returns the number of sequences in the alignment.
-
-
- .. method:: ToString(width=80)
-
- Returns a formatted string version of the alignment. The sequences are
- split into smaller parts to fit into the number columns specified.
-
- .. code-block:: python
-
- aln=seq.CreateAlignment()
- aln.AddSequence(seq.CreateSequence("A", "abcdefghik"))
- aln.AddSequence(seq.CreateSequence("B", "1234567890"))
- # The following command will print the output given below
- print aln.ToString(7)
- # A abcde
- # B 12345
- #
- # A fghik
- # B 67890
-
- .. method:: FindSequence(name)
-
- Find sequence with given name. If the alignment contains several sequences
- with the same name, the first sequence is returned.
-
- .. method:: SetSequenceName(seq_index, name)
-
- Set the name of the sequence at index `seq_index` to name
-
- .. method:: SetSequenceOffset(seq_index, offset)
-
- Set the sequence offset of sequence at index `seq_index`
-
- .. method:: Copy()
-
- Create a deep copy of the alignment
-
- .. method:: GetPos(seq_index, res_index)
-
- Get position of residue with index equal to `res_index` in sequence at index
- `seq_index`.
-
- .. method:: GetResidueIndex(seq_index, pos)
-
- Get residue index of residue at position `pos` in sequence at index
- `seq_index`.
-
- .. method:: AttachView(seq_index, view)
- AttachView(seq_index, view, chain_name)
-
- Attach the given view to the sequence at index `seq_index`.
-
- .. method:: Cut(start, end)
-
- Removes the columns in the half-closed interval `start`, `end` from the
- alignment.
-
- .. code-block:: python
-
- aln=seq.CreateAlignment()
- aln.AddSequence(seq.CreateSequence("A", "abcd---hik"))
- aln.AddSequence(seq.CreateSequence("B", "1234567890"))
- aln.Cut(4, 7)
-
- print aln.ToString(80)
- # will print
- # A abcdhik
- # B 1234890
-
- .. method:: Replace(new_region, start, end)
-
- Replace the columns in the half-closed interval `start`, `end` with the
- columns in `new_region`.
-
- :param new_region: The region to be inserted
- :type new_region: :class:`AlignedRegion` or :class:`AlignmentHandle`
-
-
- .. method:: ShiftRegion(start, end, amount, master=-1)
-
- Shift columns in the half-closed interval `start`, `end`. If amount is a
- positive number, the columns are shifted to the right, if negative, the
- columns are shifted to the left.
-
- If master is set to -1, all sequences in the region are affected, otherwise
- only the sequence at index equal to master is shifted.
diff --git a/doc/build/_static/basic.css b/doc/build/_static/basic.css
deleted file mode 100644
index 69f30d4fbe193f515cc3187d91db7216aa3544b9..0000000000000000000000000000000000000000
--- a/doc/build/_static/basic.css
+++ /dev/null
@@ -1,509 +0,0 @@
-/*
- * basic.css
- * ~~~~~~~~~
- *
- * Sphinx stylesheet -- basic theme.
- *
- * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/* -- main layout ----------------------------------------------------------- */
-
-div.clearer {
- clear: both;
-}
-
-/* -- relbar ---------------------------------------------------------------- */
-
-div.related {
- width: 100%;
- font-size: 90%;
-}
-
-div.related h3 {
- display: none;
-}
-
-div.related ul {
- margin: 0;
- padding: 0 0 0 10px;
- list-style: none;
-}
-
-div.related li {
- display: inline;
-}
-
-div.related li.right {
- float: right;
- margin-right: 5px;
-}
-
-/* -- sidebar --------------------------------------------------------------- */
-
-div.sphinxsidebarwrapper {
- padding: 10px 5px 0 10px;
-}
-
-div.sphinxsidebar {
- float: left;
- width: 230px;
- margin-left: -100%;
- font-size: 90%;
-}
-
-div.sphinxsidebar ul {
- list-style: none;
-}
-
-div.sphinxsidebar ul ul,
-div.sphinxsidebar ul.want-points {
- margin-left: 20px;
- list-style: square;
-}
-
-div.sphinxsidebar ul ul {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-div.sphinxsidebar form {
- margin-top: 10px;
-}
-
-div.sphinxsidebar input {
- border: 1px solid #98dbcc;
- font-family: sans-serif;
- font-size: 1em;
-}
-
-img {
- border: 0;
-}
-
-/* -- search page ----------------------------------------------------------- */
-
-ul.search {
- margin: 10px 0 0 20px;
- padding: 0;
-}
-
-ul.search li {
- padding: 5px 0 5px 20px;
- background-image: url(file.png);
- background-repeat: no-repeat;
- background-position: 0 7px;
-}
-
-ul.search li a {
- font-weight: bold;
-}
-
-ul.search li div.context {
- color: #888;
- margin: 2px 0 0 30px;
- text-align: left;
-}
-
-ul.keywordmatches li.goodmatch a {
- font-weight: bold;
-}
-
-/* -- index page ------------------------------------------------------------ */
-
-table.contentstable {
- width: 90%;
-}
-
-table.contentstable p.biglink {
- line-height: 150%;
-}
-
-a.biglink {
- font-size: 1.3em;
-}
-
-span.linkdescr {
- font-style: italic;
- padding-top: 5px;
- font-size: 90%;
-}
-
-/* -- general index --------------------------------------------------------- */
-
-table.indextable {
- width: 100%;
-}
-
-table.indextable td {
- text-align: left;
- vertical-align: top;
-}
-
-table.indextable dl, table.indextable dd {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-table.indextable tr.pcap {
- height: 10px;
-}
-
-table.indextable tr.cap {
- margin-top: 10px;
- background-color: #f2f2f2;
-}
-
-img.toggler {
- margin-right: 3px;
- margin-top: 3px;
- cursor: pointer;
-}
-
-div.modindex-jumpbox {
- border-top: 1px solid #ddd;
- border-bottom: 1px solid #ddd;
- margin: 1em 0 1em 0;
- padding: 0.4em;
-}
-
-div.genindex-jumpbox {
- border-top: 1px solid #ddd;
- border-bottom: 1px solid #ddd;
- margin: 1em 0 1em 0;
- padding: 0.4em;
-}
-
-/* -- general body styles --------------------------------------------------- */
-
-a.headerlink {
- visibility: hidden;
-}
-
-h1:hover > a.headerlink,
-h2:hover > a.headerlink,
-h3:hover > a.headerlink,
-h4:hover > a.headerlink,
-h5:hover > a.headerlink,
-h6:hover > a.headerlink,
-dt:hover > a.headerlink {
- visibility: visible;
-}
-
-div.body p.caption {
- text-align: inherit;
-}
-
-div.body td {
- text-align: left;
-}
-
-.field-list ul {
- padding-left: 1em;
-}
-
-.first {
- margin-top: 0 !important;
-}
-
-p.rubric {
- margin-top: 30px;
- font-weight: bold;
-}
-
-.align-left {
- text-align: left;
-}
-
-.align-center {
- clear: both;
- text-align: center;
-}
-
-.align-right {
- text-align: right;
-}
-
-/* -- sidebars -------------------------------------------------------------- */
-
-div.sidebar {
- margin: 0 0 0.5em 1em;
- border: 1px solid #ddb;
- padding: 7px 7px 0 7px;
- background-color: #ffe;
- width: 40%;
- float: right;
-}
-
-p.sidebar-title {
- font-weight: bold;
-}
-
-/* -- topics ---------------------------------------------------------------- */
-
-div.topic {
- border: 1px solid #ccc;
- padding: 7px 7px 0 7px;
- margin: 10px 0 10px 0;
-}
-
-p.topic-title {
- font-size: 1.1em;
- font-weight: bold;
- margin-top: 10px;
-}
-
-/* -- admonitions ----------------------------------------------------------- */
-
-div.admonition {
- margin-top: 10px;
- margin-bottom: 10px;
- padding: 7px;
-}
-
-div.admonition dt {
- font-weight: bold;
-}
-
-div.admonition dl {
- margin-bottom: 0;
-}
-
-p.admonition-title {
- margin: 0px 10px 5px 0px;
- font-weight: bold;
-}
-
-div.body p.centered {
- text-align: center;
- margin-top: 25px;
-}
-
-/* -- tables ---------------------------------------------------------------- */
-
-table.docutils {
- border: 0;
- border-collapse: collapse;
-}
-
-table.docutils td, table.docutils th {
- padding: 1px 8px 1px 5px;
- border-top: 0;
- border-left: 0;
- border-right: 0;
- border-bottom: 1px solid #aaa;
-}
-
-table.field-list td, table.field-list th {
- border: 0 !important;
-}
-
-table.footnote td, table.footnote th {
- border: 0 !important;
-}
-
-th {
- text-align: left;
- padding-right: 5px;
-}
-
-table.citation {
- border-left: solid 1px gray;
- margin-left: 1px;
-}
-
-table.citation td {
- border-bottom: none;
-}
-
-/* -- other body styles ----------------------------------------------------- */
-
-ol.arabic {
- list-style: decimal;
-}
-
-ol.loweralpha {
- list-style: lower-alpha;
-}
-
-ol.upperalpha {
- list-style: upper-alpha;
-}
-
-ol.lowerroman {
- list-style: lower-roman;
-}
-
-ol.upperroman {
- list-style: upper-roman;
-}
-
-dl {
- margin-bottom: 15px;
-}
-
-dd p {
- margin-top: 0px;
-}
-
-dd ul, dd table {
- margin-bottom: 10px;
-}
-
-dd {
- margin-top: 3px;
- margin-bottom: 10px;
- margin-left: 30px;
-}
-
-dt:target, .highlighted {
- background-color: #fbe54e;
-}
-
-dl.glossary dt {
- font-weight: bold;
- font-size: 1.1em;
-}
-
-.field-list ul {
- margin: 0;
- padding-left: 1em;
-}
-
-.field-list p {
- margin: 0;
-}
-
-.refcount {
- color: #060;
-}
-
-.optional {
- font-size: 1.3em;
-}
-
-.versionmodified {
- font-style: italic;
-}
-
-.system-message {
- background-color: #fda;
- padding: 5px;
- border: 3px solid red;
-}
-
-.footnote:target {
- background-color: #ffa
-}
-
-.line-block {
- display: block;
- margin-top: 1em;
- margin-bottom: 1em;
-}
-
-.line-block .line-block {
- margin-top: 0;
- margin-bottom: 0;
- margin-left: 1.5em;
-}
-
-.guilabel, .menuselection {
- font-family: sans-serif;
-}
-
-.accelerator {
- text-decoration: underline;
-}
-
-.classifier {
- font-style: oblique;
-}
-
-/* -- code displays --------------------------------------------------------- */
-
-pre {
- overflow: auto;
-}
-
-td.linenos pre {
- padding: 5px 0px;
- border: 0;
- background-color: transparent;
- color: #aaa;
-}
-
-table.highlighttable {
- margin-left: 0.5em;
-}
-
-table.highlighttable td {
- padding: 0 0.5em 0 0.5em;
-}
-
-tt.descname {
- background-color: transparent;
- font-weight: bold;
- font-size: 1.2em;
-}
-
-tt.descclassname {
- background-color: transparent;
-}
-
-tt.xref, a tt {
- background-color: transparent;
- font-weight: bold;
-}
-
-h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
- background-color: transparent;
-}
-
-.viewcode-link {
- float: right;
-}
-
-.viewcode-back {
- float: right;
- font-family: sans-serif;
-}
-
-div.viewcode-block:target {
- margin: -1px -10px;
- padding: 0 10px;
-}
-
-/* -- math display ---------------------------------------------------------- */
-
-img.math {
- vertical-align: middle;
-}
-
-div.body div.math p {
- text-align: center;
-}
-
-span.eqno {
- float: right;
-}
-
-/* -- printout stylesheet --------------------------------------------------- */
-
-@media print {
- div.document,
- div.documentwrapper,
- div.bodywrapper {
- margin: 0 !important;
- width: 100%;
- }
-
- div.sphinxsidebar,
- div.related,
- div.footer,
- #top-link {
- display: none;
- }
-}
diff --git a/doc/build/_static/contents.png b/doc/build/_static/contents.png
deleted file mode 100644
index 7fb82154a1748d507925865d3fbf7508d62483e5..0000000000000000000000000000000000000000
Binary files a/doc/build/_static/contents.png and /dev/null differ
diff --git a/doc/build/_static/default.css b/doc/build/_static/default.css
deleted file mode 100644
index 005caa1f5b819eb10777f57d8d9e3c3d5798967f..0000000000000000000000000000000000000000
--- a/doc/build/_static/default.css
+++ /dev/null
@@ -1,657 +0,0 @@
-/**
- * Sphinx Doc Design
- */
-
-body {
- font-family: sans-serif;
- font-size: 100%;
- background-color: #11303d;
- color: #000;
- margin: 0;
- padding: 0;
-}
-
-/* :::: LAYOUT :::: */
-
-div.document {
- background-color: #1c4e63;
-}
-
-div.documentwrapper {
- float: left;
- width: 100%;
-}
-
-div.bodywrapper {
- margin: 0 0 0 230px;
-}
-
-div.body {
- background-color: white;
- padding: 0 20px 30px 20px;
-}
-
-div.sphinxsidebarwrapper {
- padding: 10px 5px 0 10px;
-}
-
-div.sphinxsidebar {
- float: left;
- width: 230px;
- margin-left: -100%;
- font-size: 90%;
-}
-
-div.clearer {
- clear: both;
-}
-
-div.footer {
- color: #fff;
- width: 100%;
- padding: 9px 0 9px 0;
- text-align: center;
- font-size: 75%;
-}
-
-div.footer a {
- color: #fff;
- text-decoration: underline;
-}
-
-div.related {
- background-color: #133f52;
- color: #fff;
- width: 100%;
- line-height: 30px;
- font-size: 90%;
-}
-
-div.related h3 {
- display: none;
-}
-
-div.related ul {
- margin: 0;
- padding: 0 0 0 10px;
- list-style: none;
-}
-
-div.related li {
- display: inline;
-}
-
-div.related li.right {
- float: right;
- margin-right: 5px;
-}
-
-div.related a {
- color: white;
-}
-
-/* ::: TOC :::: */
-div.sphinxsidebar h3 {
- font-family: 'Trebuchet MS', sans-serif;
- color: white;
- font-size: 1.4em;
- font-weight: normal;
- margin: 0;
- padding: 0;
-}
-
-div.sphinxsidebar h3 a {
- color: white;
-}
-
-div.sphinxsidebar h4 {
- font-family: 'Trebuchet MS', sans-serif;
- color: white;
- font-size: 1.3em;
- font-weight: normal;
- margin: 5px 0 0 0;
- padding: 0;
-}
-
-div.sphinxsidebar p {
- color: white;
-}
-
-div.sphinxsidebar p.topless {
- margin: 5px 10px 10px 10px;
-}
-
-div.sphinxsidebar ul {
- margin: 10px;
- padding: 0;
- list-style: none;
- color: white;
-}
-
-div.sphinxsidebar ul ul,
-div.sphinxsidebar ul.want-points {
- margin-left: 20px;
- list-style: square;
-}
-
-div.sphinxsidebar ul ul {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-div.sphinxsidebar a {
- color: #98dbcc;
-}
-
-div.sphinxsidebar form {
- margin-top: 10px;
-}
-
-div.sphinxsidebar input {
- border: 1px solid #98dbcc;
- font-family: sans-serif;
- font-size: 1em;
-}
-
-/* :::: MODULE CLOUD :::: */
-div.modulecloud {
- margin: -5px 10px 5px 10px;
- padding: 10px;
- line-height: 160%;
- border: 1px solid #cbe7e5;
- background-color: #f2fbfd;
-}
-
-div.modulecloud a {
- padding: 0 5px 0 5px;
-}
-
-/* :::: SEARCH :::: */
-ul.search {
- margin: 10px 0 0 20px;
- padding: 0;
-}
-
-ul.search li {
- padding: 5px 0 5px 20px;
- background-image: url(file.png);
- background-repeat: no-repeat;
- background-position: 0 7px;
-}
-
-ul.search li a {
- font-weight: bold;
-}
-
-ul.search li div.context {
- color: #888;
- margin: 2px 0 0 30px;
- text-align: left;
-}
-
-ul.keywordmatches li.goodmatch a {
- font-weight: bold;
-}
-
-/* :::: COMMON FORM STYLES :::: */
-
-div.actions {
- padding: 5px 10px 5px 10px;
- border-top: 1px solid #cbe7e5;
- border-bottom: 1px solid #cbe7e5;
- background-color: #e0f6f4;
-}
-
-form dl {
- color: #333;
-}
-
-form dt {
- clear: both;
- float: left;
- min-width: 110px;
- margin-right: 10px;
- padding-top: 2px;
-}
-
-input#homepage {
- display: none;
-}
-
-div.error {
- margin: 5px 20px 0 0;
- padding: 5px;
- border: 1px solid #d00;
- font-weight: bold;
-}
-
-/* :::: INDEX PAGE :::: */
-
-table.contentstable {
- width: 90%;
-}
-
-table.contentstable p.biglink {
- line-height: 150%;
-}
-
-a.biglink {
- font-size: 1.3em;
-}
-
-span.linkdescr {
- font-style: italic;
- padding-top: 5px;
- font-size: 90%;
-}
-
-/* :::: INDEX STYLES :::: */
-
-table.indextable td {
- text-align: left;
- vertical-align: top;
-}
-
-table.indextable dl, table.indextable dd {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-table.indextable tr.pcap {
- height: 10px;
-}
-
-table.indextable tr.cap {
- margin-top: 10px;
- background-color: #f2f2f2;
-}
-
-img.toggler {
- margin-right: 3px;
- margin-top: 3px;
- cursor: pointer;
-}
-
-form.pfform {
- margin: 10px 0 20px 0;
-}
-
-/* :::: GLOBAL STYLES :::: */
-
-.docwarning {
- background-color: #ffe4e4;
- padding: 10px;
- margin: 0 -20px 0 -20px;
- border-bottom: 1px solid #f66;
-}
-
-p.subhead {
- font-weight: bold;
- margin-top: 20px;
-}
-
-a {
- color: #355f7c;
- text-decoration: none;
-}
-
-a:hover {
- text-decoration: underline;
-}
-
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
- font-family: 'Trebuchet MS', sans-serif;
- background-color: #f2f2f2;
- font-weight: normal;
- color: #20435c;
- border-bottom: 1px solid #ccc;
- margin: 20px -20px 10px -20px;
- padding: 3px 0 3px 10px;
-}
-
-div.body h1 { margin-top: 0; font-size: 200%; }
-div.body h2 { font-size: 160%; }
-div.body h3 { font-size: 140%; }
-div.body h4 { font-size: 120%; }
-div.body h5 { font-size: 110%; }
-div.body h6 { font-size: 100%; }
-
-a.headerlink {
- color: #c60f0f;
- font-size: 0.8em;
- padding: 0 4px 0 4px;
- text-decoration: none;
- visibility: hidden;
-}
-
-h1:hover > a.headerlink,
-h2:hover > a.headerlink,
-h3:hover > a.headerlink,
-h4:hover > a.headerlink,
-h5:hover > a.headerlink,
-h6:hover > a.headerlink,
-dt:hover > a.headerlink {
- visibility: visible;
-}
-
-a.headerlink:hover {
- background-color: #c60f0f;
- color: white;
-}
-
-div.body p, div.body dd, div.body li {
- text-align: justify;
- line-height: 130%;
-}
-
-div.body p.caption {
- text-align: inherit;
-}
-
-div.body td {
- text-align: left;
-}
-
-ul.fakelist {
- list-style: none;
- margin: 10px 0 10px 20px;
- padding: 0;
-}
-
-.field-list ul {
- padding-left: 1em;
-}
-
-.first {
- margin-top: 0 !important;
-}
-
-/* "Footnotes" heading */
-p.rubric {
- margin-top: 30px;
- font-weight: bold;
-}
-
-/* Sidebars */
-
-div.sidebar {
- margin: 0 0 0.5em 1em;
- border: 1px solid #ddb;
- padding: 7px 7px 0 7px;
- background-color: #ffe;
- width: 40%;
- float: right;
-}
-
-p.sidebar-title {
- font-weight: bold;
-}
-
-/* "Topics" */
-
-div.topic {
- background-color: #eee;
- border: 1px solid #ccc;
- padding: 7px 7px 0 7px;
- margin: 10px 0 10px 0;
-}
-
-p.topic-title {
- font-size: 1.1em;
- font-weight: bold;
- margin-top: 10px;
-}
-
-/* Admonitions */
-
-div.admonition {
- margin-top: 10px;
- margin-bottom: 10px;
- padding: 7px;
-}
-
-div.admonition dt {
- font-weight: bold;
-}
-
-div.admonition dl {
- margin-bottom: 0;
-}
-
-div.admonition p.admonition-title + p {
- display: inline;
-}
-
-div.seealso {
- background-color: #ffc;
- border: 1px solid #ff6;
-}
-
-div.warning {
- background-color: #ffe4e4;
- border: 1px solid #f66;
-}
-
-div.note {
- background-color: #eee;
- border: 1px solid #ccc;
-}
-
-p.admonition-title {
- margin: 0px 10px 5px 0px;
- font-weight: bold;
- display: inline;
-}
-
-p.admonition-title:after {
- content: ":";
-}
-
-div.body p.centered {
- text-align: center;
- margin-top: 25px;
-}
-
-table.docutils {
- border: 0;
-}
-
-table.docutils td, table.docutils th {
- padding: 1px 8px 1px 0;
- border-top: 0;
- border-left: 0;
- border-right: 0;
- border-bottom: 1px solid #aaa;
-}
-
-table.field-list td, table.field-list th {
- border: 0 !important;
-}
-
-table.footnote td, table.footnote th {
- border: 0 !important;
-}
-
-.field-list ul {
- margin: 0;
- padding-left: 1em;
-}
-
-.field-list p {
- margin: 0;
-}
-
-dl {
- margin-bottom: 15px;
- clear: both;
-}
-
-dd p {
- margin-top: 0px;
-}
-
-dd ul, dd table {
- margin-bottom: 10px;
-}
-
-dd {
- margin-top: 3px;
- margin-bottom: 10px;
- margin-left: 30px;
-}
-
-.refcount {
- color: #060;
-}
-
-dt:target,
-.highlight {
- background-color: #fbe54e;
-}
-
-dl.glossary dt {
- font-weight: bold;
- font-size: 1.1em;
-}
-
-th {
- text-align: left;
- padding-right: 5px;
-}
-
-pre {
- padding: 5px;
- background-color: #efc;
- color: #333;
- border: 1px solid #ac9;
- border-left: none;
- border-right: none;
- overflow: auto;
-}
-
-td.linenos pre {
- padding: 5px 0px;
- border: 0;
- background-color: transparent;
- color: #aaa;
-}
-
-table.highlighttable {
- margin-left: 0.5em;
-}
-
-table.highlighttable td {
- padding: 0 0.5em 0 0.5em;
-}
-
-tt {
- background-color: #ecf0f3;
- padding: 0 1px 0 1px;
- font-size: 0.95em;
-}
-
-tt.descname {
- background-color: transparent;
- font-weight: bold;
- font-size: 1.2em;
-}
-
-tt.descclassname {
- background-color: transparent;
-}
-
-tt.xref, a tt {
- background-color: transparent;
- font-weight: bold;
-}
-
-.footnote:target { background-color: #ffa }
-
-h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
- background-color: transparent;
-}
-
-.optional {
- font-size: 1.3em;
-}
-
-.versionmodified {
- font-style: italic;
-}
-
-form.comment {
- margin: 0;
- padding: 10px 30px 10px 30px;
- background-color: #eee;
-}
-
-form.comment h3 {
- background-color: #326591;
- color: white;
- margin: -10px -30px 10px -30px;
- padding: 5px;
- font-size: 1.4em;
-}
-
-form.comment input,
-form.comment textarea {
- border: 1px solid #ccc;
- padding: 2px;
- font-family: sans-serif;
- font-size: 100%;
-}
-
-form.comment input[type="text"] {
- width: 240px;
-}
-
-form.comment textarea {
- width: 100%;
- height: 200px;
- margin-bottom: 10px;
-}
-
-.system-message {
- background-color: #fda;
- padding: 5px;
- border: 3px solid red;
-}
-
-img.math {
- vertical-align: middle;
-}
-
-div.math p {
- text-align: center;
-}
-
-span.eqno {
- float: right;
-}
-
-img.logo {
- border: 0;
-}
-
-/* :::: PRINT :::: */
-@media print {
- div.document,
- div.documentwrapper,
- div.bodywrapper {
- margin: 0;
- width : 100%;
- }
-
- div.sphinxsidebar,
- div.related,
- div.footer,
- div#comments div.new-comment-box,
- #top-link {
- display: none;
- }
-}
diff --git a/doc/build/_static/doctools.js b/doc/build/_static/doctools.js
deleted file mode 100644
index eeea95ea5ffd8e5a1be5aff231c61e26a2b175f1..0000000000000000000000000000000000000000
--- a/doc/build/_static/doctools.js
+++ /dev/null
@@ -1,247 +0,0 @@
-/*
- * doctools.js
- * ~~~~~~~~~~~
- *
- * Sphinx JavaScript utilties for all documentation.
- *
- * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/**
- * select a different prefix for underscore
- */
-$u = _.noConflict();
-
-/**
- * make the code below compatible with browsers without
- * an installed firebug like debugger
-if (!window.console || !console.firebug) {
- var names = ["log", "debug", "info", "warn", "error", "assert", "dir",
- "dirxml", "group", "groupEnd", "time", "timeEnd", "count", "trace",
- "profile", "profileEnd"];
- window.console = {};
- for (var i = 0; i < names.length; ++i)
- window.console[names[i]] = function() {};
-}
- */
-
-/**
- * small helper function to urldecode strings
- */
-jQuery.urldecode = function(x) {
- return decodeURIComponent(x).replace(/\+/g, ' ');
-}
-
-/**
- * small helper function to urlencode strings
- */
-jQuery.urlencode = encodeURIComponent;
-
-/**
- * This function returns the parsed url parameters of the
- * current request. Multiple values per key are supported,
- * it will always return arrays of strings for the value parts.
- */
-jQuery.getQueryParameters = function(s) {
- if (typeof s == 'undefined')
- s = document.location.search;
- var parts = s.substr(s.indexOf('?') + 1).split('&');
- var result = {};
- for (var i = 0; i < parts.length; i++) {
- var tmp = parts[i].split('=', 2);
- var key = jQuery.urldecode(tmp[0]);
- var value = jQuery.urldecode(tmp[1]);
- if (key in result)
- result[key].push(value);
- else
- result[key] = [value];
- }
- return result;
-};
-
-/**
- * small function to check if an array contains
- * a given item.
- */
-jQuery.contains = function(arr, item) {
- for (var i = 0; i < arr.length; i++) {
- if (arr[i] == item)
- return true;
- }
- return false;
-};
-
-/**
- * highlight a given string on a jquery object by wrapping it in
- * span elements with the given class name.
- */
-jQuery.fn.highlightText = function(text, className) {
- function highlight(node) {
- if (node.nodeType == 3) {
- var val = node.nodeValue;
- var pos = val.toLowerCase().indexOf(text);
- if (pos >= 0 && !jQuery(node.parentNode).hasClass(className)) {
- var span = document.createElement("span");
- span.className = className;
- span.appendChild(document.createTextNode(val.substr(pos, text.length)));
- node.parentNode.insertBefore(span, node.parentNode.insertBefore(
- document.createTextNode(val.substr(pos + text.length)),
- node.nextSibling));
- node.nodeValue = val.substr(0, pos);
- }
- }
- else if (!jQuery(node).is("button, select, textarea")) {
- jQuery.each(node.childNodes, function() {
- highlight(this);
- });
- }
- }
- return this.each(function() {
- highlight(this);
- });
-};
-
-/**
- * Small JavaScript module for the documentation.
- */
-var Documentation = {
-
- init : function() {
- this.fixFirefoxAnchorBug();
- this.highlightSearchWords();
- this.initIndexTable();
- },
-
- /**
- * i18n support
- */
- TRANSLATIONS : {},
- PLURAL_EXPR : function(n) { return n == 1 ? 0 : 1; },
- LOCALE : 'unknown',
-
- // gettext and ngettext don't access this so that the functions
- // can safely bound to a different name (_ = Documentation.gettext)
- gettext : function(string) {
- var translated = Documentation.TRANSLATIONS[string];
- if (typeof translated == 'undefined')
- return string;
- return (typeof translated == 'string') ? translated : translated[0];
- },
-
- ngettext : function(singular, plural, n) {
- var translated = Documentation.TRANSLATIONS[singular];
- if (typeof translated == 'undefined')
- return (n == 1) ? singular : plural;
- return translated[Documentation.PLURALEXPR(n)];
- },
-
- addTranslations : function(catalog) {
- for (var key in catalog.messages)
- this.TRANSLATIONS[key] = catalog.messages[key];
- this.PLURAL_EXPR = new Function('n', 'return +(' + catalog.plural_expr + ')');
- this.LOCALE = catalog.locale;
- },
-
- /**
- * add context elements like header anchor links
- */
- addContextElements : function() {
- $('div[id] > :header:first').each(function() {
- $('<a class="headerlink">\u00B6</a>').
- attr('href', '#' + this.id).
- attr('title', _('Permalink to this headline')).
- appendTo(this);
- });
- $('dt[id]').each(function() {
- $('<a class="headerlink">\u00B6</a>').
- attr('href', '#' + this.id).
- attr('title', _('Permalink to this definition')).
- appendTo(this);
- });
- },
-
- /**
- * workaround a firefox stupidity
- */
- fixFirefoxAnchorBug : function() {
- if (document.location.hash && $.browser.mozilla)
- window.setTimeout(function() {
- document.location.href += '';
- }, 10);
- },
-
- /**
- * highlight the search words provided in the url in the text
- */
- highlightSearchWords : function() {
- var params = $.getQueryParameters();
- var terms = (params.highlight) ? params.highlight[0].split(/\s+/) : [];
- if (terms.length) {
- var body = $('div.body');
- window.setTimeout(function() {
- $.each(terms, function() {
- body.highlightText(this.toLowerCase(), 'highlighted');
- });
- }, 10);
- $('<li class="highlight-link"><a href="javascript:Documentation.' +
- 'hideSearchWords()">' + _('Hide Search Matches') + '</a></li>')
- .appendTo($('.sidebar .this-page-menu'));
- }
- },
-
- /**
- * init the domain index toggle buttons
- */
- initIndexTable : function() {
- var togglers = $('img.toggler').click(function() {
- var src = $(this).attr('src');
- var idnum = $(this).attr('id').substr(7);
- $('tr.cg-' + idnum).toggle();
- if (src.substr(-9) == 'minus.png')
- $(this).attr('src', src.substr(0, src.length-9) + 'plus.png');
- else
- $(this).attr('src', src.substr(0, src.length-8) + 'minus.png');
- }).css('display', '');
- if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) {
- togglers.click();
- }
- },
-
- /**
- * helper function to hide the search marks again
- */
- hideSearchWords : function() {
- $('.sidebar .this-page-menu li.highlight-link').fadeOut(300);
- $('span.highlighted').removeClass('highlighted');
- },
-
- /**
- * make the url absolute
- */
- makeURL : function(relativeURL) {
- return DOCUMENTATION_OPTIONS.URL_ROOT + '/' + relativeURL;
- },
-
- /**
- * get the current relative url
- */
- getCurrentURL : function() {
- var path = document.location.pathname;
- var parts = path.split(/\//);
- $.each(DOCUMENTATION_OPTIONS.URL_ROOT.split(/\//), function() {
- if (this == '..')
- parts.pop();
- });
- var url = parts.join('/');
- return path.substring(url.lastIndexOf('/') + 1, path.length - 1);
- }
-};
-
-// quick alias for translations
-_ = Documentation.gettext;
-
-$(document).ready(function() {
- Documentation.init();
-});
diff --git a/doc/build/_static/file.png b/doc/build/_static/file.png
deleted file mode 100644
index d18082e397e7e54f20721af768c4c2983258f1b4..0000000000000000000000000000000000000000
Binary files a/doc/build/_static/file.png and /dev/null differ
diff --git a/doc/build/_static/jquery.js b/doc/build/_static/jquery.js
deleted file mode 100644
index 7c243080233761859937d52195b670602731a379..0000000000000000000000000000000000000000
--- a/doc/build/_static/jquery.js
+++ /dev/null
@@ -1,154 +0,0 @@
-/*!
- * jQuery JavaScript Library v1.4.2
- * http://jquery.com/
- *
- * Copyright 2010, John Resig
- * Dual licensed under the MIT or GPL Version 2 licenses.
- * http://jquery.org/license
- *
- * Includes Sizzle.js
- * http://sizzlejs.com/
- * Copyright 2010, The Dojo Foundation
- * Released under the MIT, BSD, and GPL Licenses.
- *
- * Date: Sat Feb 13 22:33:48 2010 -0500
- */
-(function(A,w){function ma(){if(!c.isReady){try{s.documentElement.doScroll("left")}catch(a){setTimeout(ma,1);return}c.ready()}}function Qa(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function X(a,b,d,f,e,j){var i=a.length;if(typeof b==="object"){for(var o in b)X(a,o,b[o],f,e,d);return a}if(d!==w){f=!j&&f&&c.isFunction(d);for(o=0;o<i;o++)e(a[o],b,f?d.call(a[o],o,e(a[o],b)):d,j);return a}return i?
-e(a[0],b):w}function J(){return(new Date).getTime()}function Y(){return false}function Z(){return true}function na(a,b,d){d[0].type=a;return c.event.handle.apply(b,d)}function oa(a){var b,d=[],f=[],e=arguments,j,i,o,k,n,r;i=c.data(this,"events");if(!(a.liveFired===this||!i||!i.live||a.button&&a.type==="click")){a.liveFired=this;var u=i.live.slice(0);for(k=0;k<u.length;k++){i=u[k];i.origType.replace(O,"")===a.type?f.push(i.selector):u.splice(k--,1)}j=c(a.target).closest(f,a.currentTarget);n=0;for(r=
-j.length;n<r;n++)for(k=0;k<u.length;k++){i=u[k];if(j[n].selector===i.selector){o=j[n].elem;f=null;if(i.preType==="mouseenter"||i.preType==="mouseleave")f=c(a.relatedTarget).closest(i.selector)[0];if(!f||f!==o)d.push({elem:o,handleObj:i})}}n=0;for(r=d.length;n<r;n++){j=d[n];a.currentTarget=j.elem;a.data=j.handleObj.data;a.handleObj=j.handleObj;if(j.handleObj.origHandler.apply(j.elem,e)===false){b=false;break}}return b}}function pa(a,b){return"live."+(a&&a!=="*"?a+".":"")+b.replace(/\./g,"`").replace(/ /g,
-"&")}function qa(a){return!a||!a.parentNode||a.parentNode.nodeType===11}function ra(a,b){var d=0;b.each(function(){if(this.nodeName===(a[d]&&a[d].nodeName)){var f=c.data(a[d++]),e=c.data(this,f);if(f=f&&f.events){delete e.handle;e.events={};for(var j in f)for(var i in f[j])c.event.add(this,j,f[j][i],f[j][i].data)}}})}function sa(a,b,d){var f,e,j;b=b&&b[0]?b[0].ownerDocument||b[0]:s;if(a.length===1&&typeof a[0]==="string"&&a[0].length<512&&b===s&&!ta.test(a[0])&&(c.support.checkClone||!ua.test(a[0]))){e=
-true;if(j=c.fragments[a[0]])if(j!==1)f=j}if(!f){f=b.createDocumentFragment();c.clean(a,b,f,d)}if(e)c.fragments[a[0]]=j?f:1;return{fragment:f,cacheable:e}}function K(a,b){var d={};c.each(va.concat.apply([],va.slice(0,b)),function(){d[this]=a});return d}function wa(a){return"scrollTo"in a&&a.document?a:a.nodeType===9?a.defaultView||a.parentWindow:false}var c=function(a,b){return new c.fn.init(a,b)},Ra=A.jQuery,Sa=A.$,s=A.document,T,Ta=/^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,Ua=/^.[^:#\[\.,]*$/,Va=/\S/,
-Wa=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,Xa=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,P=navigator.userAgent,xa=false,Q=[],L,$=Object.prototype.toString,aa=Object.prototype.hasOwnProperty,ba=Array.prototype.push,R=Array.prototype.slice,ya=Array.prototype.indexOf;c.fn=c.prototype={init:function(a,b){var d,f;if(!a)return this;if(a.nodeType){this.context=this[0]=a;this.length=1;return this}if(a==="body"&&!b){this.context=s;this[0]=s.body;this.selector="body";this.length=1;return this}if(typeof a==="string")if((d=Ta.exec(a))&&
-(d[1]||!b))if(d[1]){f=b?b.ownerDocument||b:s;if(a=Xa.exec(a))if(c.isPlainObject(b)){a=[s.createElement(a[1])];c.fn.attr.call(a,b,true)}else a=[f.createElement(a[1])];else{a=sa([d[1]],[f]);a=(a.cacheable?a.fragment.cloneNode(true):a.fragment).childNodes}return c.merge(this,a)}else{if(b=s.getElementById(d[2])){if(b.id!==d[2])return T.find(a);this.length=1;this[0]=b}this.context=s;this.selector=a;return this}else if(!b&&/^\w+$/.test(a)){this.selector=a;this.context=s;a=s.getElementsByTagName(a);return c.merge(this,
-a)}else return!b||b.jquery?(b||T).find(a):c(b).find(a);else if(c.isFunction(a))return T.ready(a);if(a.selector!==w){this.selector=a.selector;this.context=a.context}return c.makeArray(a,this)},selector:"",jquery:"1.4.2",length:0,size:function(){return this.length},toArray:function(){return R.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this.slice(a)[0]:this[a]},pushStack:function(a,b,d){var f=c();c.isArray(a)?ba.apply(f,a):c.merge(f,a);f.prevObject=this;f.context=this.context;if(b===
-"find")f.selector=this.selector+(this.selector?" ":"")+d;else if(b)f.selector=this.selector+"."+b+"("+d+")";return f},each:function(a,b){return c.each(this,a,b)},ready:function(a){c.bindReady();if(c.isReady)a.call(s,c);else Q&&Q.push(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(R.apply(this,arguments),"slice",R.call(arguments).join(","))},map:function(a){return this.pushStack(c.map(this,
-function(b,d){return a.call(b,d,b)}))},end:function(){return this.prevObject||c(null)},push:ba,sort:[].sort,splice:[].splice};c.fn.init.prototype=c.fn;c.extend=c.fn.extend=function(){var a=arguments[0]||{},b=1,d=arguments.length,f=false,e,j,i,o;if(typeof a==="boolean"){f=a;a=arguments[1]||{};b=2}if(typeof a!=="object"&&!c.isFunction(a))a={};if(d===b){a=this;--b}for(;b<d;b++)if((e=arguments[b])!=null)for(j in e){i=a[j];o=e[j];if(a!==o)if(f&&o&&(c.isPlainObject(o)||c.isArray(o))){i=i&&(c.isPlainObject(i)||
-c.isArray(i))?i:c.isArray(o)?[]:{};a[j]=c.extend(f,i,o)}else if(o!==w)a[j]=o}return a};c.extend({noConflict:function(a){A.$=Sa;if(a)A.jQuery=Ra;return c},isReady:false,ready:function(){if(!c.isReady){if(!s.body)return setTimeout(c.ready,13);c.isReady=true;if(Q){for(var a,b=0;a=Q[b++];)a.call(s,c);Q=null}c.fn.triggerHandler&&c(s).triggerHandler("ready")}},bindReady:function(){if(!xa){xa=true;if(s.readyState==="complete")return c.ready();if(s.addEventListener){s.addEventListener("DOMContentLoaded",
-L,false);A.addEventListener("load",c.ready,false)}else if(s.attachEvent){s.attachEvent("onreadystatechange",L);A.attachEvent("onload",c.ready);var a=false;try{a=A.frameElement==null}catch(b){}s.documentElement.doScroll&&a&&ma()}}},isFunction:function(a){return $.call(a)==="[object Function]"},isArray:function(a){return $.call(a)==="[object Array]"},isPlainObject:function(a){if(!a||$.call(a)!=="[object Object]"||a.nodeType||a.setInterval)return false;if(a.constructor&&!aa.call(a,"constructor")&&!aa.call(a.constructor.prototype,
-"isPrototypeOf"))return false;var b;for(b in a);return b===w||aa.call(a,b)},isEmptyObject:function(a){for(var b in a)return false;return true},error:function(a){throw a;},parseJSON:function(a){if(typeof a!=="string"||!a)return null;a=c.trim(a);if(/^[\],:{}\s]*$/.test(a.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,"@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:\s*\[)+/g,"")))return A.JSON&&A.JSON.parse?A.JSON.parse(a):(new Function("return "+
-a))();else c.error("Invalid JSON: "+a)},noop:function(){},globalEval:function(a){if(a&&Va.test(a)){var b=s.getElementsByTagName("head")[0]||s.documentElement,d=s.createElement("script");d.type="text/javascript";if(c.support.scriptEval)d.appendChild(s.createTextNode(a));else d.text=a;b.insertBefore(d,b.firstChild);b.removeChild(d)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,b,d){var f,e=0,j=a.length,i=j===w||c.isFunction(a);if(d)if(i)for(f in a){if(b.apply(a[f],
-d)===false)break}else for(;e<j;){if(b.apply(a[e++],d)===false)break}else if(i)for(f in a){if(b.call(a[f],f,a[f])===false)break}else for(d=a[0];e<j&&b.call(d,e,d)!==false;d=a[++e]);return a},trim:function(a){return(a||"").replace(Wa,"")},makeArray:function(a,b){b=b||[];if(a!=null)a.length==null||typeof a==="string"||c.isFunction(a)||typeof a!=="function"&&a.setInterval?ba.call(b,a):c.merge(b,a);return b},inArray:function(a,b){if(b.indexOf)return b.indexOf(a);for(var d=0,f=b.length;d<f;d++)if(b[d]===
-a)return d;return-1},merge:function(a,b){var d=a.length,f=0;if(typeof b.length==="number")for(var e=b.length;f<e;f++)a[d++]=b[f];else for(;b[f]!==w;)a[d++]=b[f++];a.length=d;return a},grep:function(a,b,d){for(var f=[],e=0,j=a.length;e<j;e++)!d!==!b(a[e],e)&&f.push(a[e]);return f},map:function(a,b,d){for(var f=[],e,j=0,i=a.length;j<i;j++){e=b(a[j],j,d);if(e!=null)f[f.length]=e}return f.concat.apply([],f)},guid:1,proxy:function(a,b,d){if(arguments.length===2)if(typeof b==="string"){d=a;a=d[b];b=w}else if(b&&
-!c.isFunction(b)){d=b;b=w}if(!b&&a)b=function(){return a.apply(d||this,arguments)};if(a)b.guid=a.guid=a.guid||b.guid||c.guid++;return b},uaMatch:function(a){a=a.toLowerCase();a=/(webkit)[ \/]([\w.]+)/.exec(a)||/(opera)(?:.*version)?[ \/]([\w.]+)/.exec(a)||/(msie) ([\w.]+)/.exec(a)||!/compatible/.test(a)&&/(mozilla)(?:.*? rv:([\w.]+))?/.exec(a)||[];return{browser:a[1]||"",version:a[2]||"0"}},browser:{}});P=c.uaMatch(P);if(P.browser){c.browser[P.browser]=true;c.browser.version=P.version}if(c.browser.webkit)c.browser.safari=
-true;if(ya)c.inArray=function(a,b){return ya.call(b,a)};T=c(s);if(s.addEventListener)L=function(){s.removeEventListener("DOMContentLoaded",L,false);c.ready()};else if(s.attachEvent)L=function(){if(s.readyState==="complete"){s.detachEvent("onreadystatechange",L);c.ready()}};(function(){c.support={};var a=s.documentElement,b=s.createElement("script"),d=s.createElement("div"),f="script"+J();d.style.display="none";d.innerHTML=" <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
-var e=d.getElementsByTagName("*"),j=d.getElementsByTagName("a")[0];if(!(!e||!e.length||!j)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(j.getAttribute("style")),hrefNormalized:j.getAttribute("href")==="/a",opacity:/^0.55$/.test(j.style.opacity),cssFloat:!!j.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:s.createElement("select").appendChild(s.createElement("option")).selected,
-parentNode:d.removeChild(d.appendChild(s.createElement("div"))).parentNode===null,deleteExpando:true,checkClone:false,scriptEval:false,noCloneEvent:true,boxModel:null};b.type="text/javascript";try{b.appendChild(s.createTextNode("window."+f+"=1;"))}catch(i){}a.insertBefore(b,a.firstChild);if(A[f]){c.support.scriptEval=true;delete A[f]}try{delete b.test}catch(o){c.support.deleteExpando=false}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function k(){c.support.noCloneEvent=
-false;d.detachEvent("onclick",k)});d.cloneNode(true).fireEvent("onclick")}d=s.createElement("div");d.innerHTML="<input type='radio' name='radiotest' checked='checked'/>";a=s.createDocumentFragment();a.appendChild(d.firstChild);c.support.checkClone=a.cloneNode(true).cloneNode(true).lastChild.checked;c(function(){var k=s.createElement("div");k.style.width=k.style.paddingLeft="1px";s.body.appendChild(k);c.boxModel=c.support.boxModel=k.offsetWidth===2;s.body.removeChild(k).style.display="none"});a=function(k){var n=
-s.createElement("div");k="on"+k;var r=k in n;if(!r){n.setAttribute(k,"return;");r=typeof n[k]==="function"}return r};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=e=j=null}})();c.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"};var G="jQuery"+J(),Ya=0,za={};c.extend({cache:{},expando:G,noData:{embed:true,object:true,
-applet:true},data:function(a,b,d){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var f=a[G],e=c.cache;if(!f&&typeof b==="string"&&d===w)return null;f||(f=++Ya);if(typeof b==="object"){a[G]=f;e[f]=c.extend(true,{},b)}else if(!e[f]){a[G]=f;e[f]={}}a=e[f];if(d!==w)a[b]=d;return typeof b==="string"?a[b]:a}},removeData:function(a,b){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?za:a;var d=a[G],f=c.cache,e=f[d];if(b){if(e){delete e[b];c.isEmptyObject(e)&&c.removeData(a)}}else{if(c.support.deleteExpando)delete a[c.expando];
-else a.removeAttribute&&a.removeAttribute(c.expando);delete f[d]}}}});c.fn.extend({data:function(a,b){if(typeof a==="undefined"&&this.length)return c.data(this[0]);else if(typeof a==="object")return this.each(function(){c.data(this,a)});var d=a.split(".");d[1]=d[1]?"."+d[1]:"";if(b===w){var f=this.triggerHandler("getData"+d[1]+"!",[d[0]]);if(f===w&&this.length)f=c.data(this[0],a);return f===w&&d[1]?this.data(d[0]):f}else return this.trigger("setData"+d[1]+"!",[d[0],b]).each(function(){c.data(this,
-a,b)})},removeData:function(a){return this.each(function(){c.removeData(this,a)})}});c.extend({queue:function(a,b,d){if(a){b=(b||"fx")+"queue";var f=c.data(a,b);if(!d)return f||[];if(!f||c.isArray(d))f=c.data(a,b,c.makeArray(d));else f.push(d);return f}},dequeue:function(a,b){b=b||"fx";var d=c.queue(a,b),f=d.shift();if(f==="inprogress")f=d.shift();if(f){b==="fx"&&d.unshift("inprogress");f.call(a,function(){c.dequeue(a,b)})}}});c.fn.extend({queue:function(a,b){if(typeof a!=="string"){b=a;a="fx"}if(b===
-w)return c.queue(this[0],a);return this.each(function(){var d=c.queue(this,a,b);a==="fx"&&d[0]!=="inprogress"&&c.dequeue(this,a)})},dequeue:function(a){return this.each(function(){c.dequeue(this,a)})},delay:function(a,b){a=c.fx?c.fx.speeds[a]||a:a;b=b||"fx";return this.queue(b,function(){var d=this;setTimeout(function(){c.dequeue(d,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var Aa=/[\n\t]/g,ca=/\s+/,Za=/\r/g,$a=/href|src|style/,ab=/(button|input)/i,bb=/(button|input|object|select|textarea)/i,
-cb=/^(a|area)$/i,Ba=/radio|checkbox/;c.fn.extend({attr:function(a,b){return X(this,a,b,true,c.attr)},removeAttr:function(a){return this.each(function(){c.attr(this,a,"");this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(c.isFunction(a))return this.each(function(n){var r=c(this);r.addClass(a.call(this,n,r.attr("class")))});if(a&&typeof a==="string")for(var b=(a||"").split(ca),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1)if(e.className){for(var j=" "+e.className+" ",
-i=e.className,o=0,k=b.length;o<k;o++)if(j.indexOf(" "+b[o]+" ")<0)i+=" "+b[o];e.className=c.trim(i)}else e.className=a}return this},removeClass:function(a){if(c.isFunction(a))return this.each(function(k){var n=c(this);n.removeClass(a.call(this,k,n.attr("class")))});if(a&&typeof a==="string"||a===w)for(var b=(a||"").split(ca),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1&&e.className)if(a){for(var j=(" "+e.className+" ").replace(Aa," "),i=0,o=b.length;i<o;i++)j=j.replace(" "+b[i]+" ",
-" ");e.className=c.trim(j)}else e.className=""}return this},toggleClass:function(a,b){var d=typeof a,f=typeof b==="boolean";if(c.isFunction(a))return this.each(function(e){var j=c(this);j.toggleClass(a.call(this,e,j.attr("class"),b),b)});return this.each(function(){if(d==="string")for(var e,j=0,i=c(this),o=b,k=a.split(ca);e=k[j++];){o=f?o:!i.hasClass(e);i[o?"addClass":"removeClass"](e)}else if(d==="undefined"||d==="boolean"){this.className&&c.data(this,"__className__",this.className);this.className=
-this.className||a===false?"":c.data(this,"__className__")||""}})},hasClass:function(a){a=" "+a+" ";for(var b=0,d=this.length;b<d;b++)if((" "+this[b].className+" ").replace(Aa," ").indexOf(a)>-1)return true;return false},val:function(a){if(a===w){var b=this[0];if(b){if(c.nodeName(b,"option"))return(b.attributes.value||{}).specified?b.value:b.text;if(c.nodeName(b,"select")){var d=b.selectedIndex,f=[],e=b.options;b=b.type==="select-one";if(d<0)return null;var j=b?d:0;for(d=b?d+1:e.length;j<d;j++){var i=
-e[j];if(i.selected){a=c(i).val();if(b)return a;f.push(a)}}return f}if(Ba.test(b.type)&&!c.support.checkOn)return b.getAttribute("value")===null?"on":b.value;return(b.value||"").replace(Za,"")}return w}var o=c.isFunction(a);return this.each(function(k){var n=c(this),r=a;if(this.nodeType===1){if(o)r=a.call(this,k,n.val());if(typeof r==="number")r+="";if(c.isArray(r)&&Ba.test(this.type))this.checked=c.inArray(n.val(),r)>=0;else if(c.nodeName(this,"select")){var u=c.makeArray(r);c("option",this).each(function(){this.selected=
-c.inArray(c(this).val(),u)>=0});if(!u.length)this.selectedIndex=-1}else this.value=r}})}});c.extend({attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(a,b,d,f){if(!a||a.nodeType===3||a.nodeType===8)return w;if(f&&b in c.attrFn)return c(a)[b](d);f=a.nodeType!==1||!c.isXMLDoc(a);var e=d!==w;b=f&&c.props[b]||b;if(a.nodeType===1){var j=$a.test(b);if(b in a&&f&&!j){if(e){b==="type"&&ab.test(a.nodeName)&&a.parentNode&&c.error("type property can't be changed");
-a[b]=d}if(c.nodeName(a,"form")&&a.getAttributeNode(b))return a.getAttributeNode(b).nodeValue;if(b==="tabIndex")return(b=a.getAttributeNode("tabIndex"))&&b.specified?b.value:bb.test(a.nodeName)||cb.test(a.nodeName)&&a.href?0:w;return a[b]}if(!c.support.style&&f&&b==="style"){if(e)a.style.cssText=""+d;return a.style.cssText}e&&a.setAttribute(b,""+d);a=!c.support.hrefNormalized&&f&&j?a.getAttribute(b,2):a.getAttribute(b);return a===null?w:a}return c.style(a,b,d)}});var O=/\.(.*)$/,db=function(a){return a.replace(/[^\w\s\.\|`]/g,
-function(b){return"\\"+b})};c.event={add:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){if(a.setInterval&&a!==A&&!a.frameElement)a=A;var e,j;if(d.handler){e=d;d=e.handler}if(!d.guid)d.guid=c.guid++;if(j=c.data(a)){var i=j.events=j.events||{},o=j.handle;if(!o)j.handle=o=function(){return typeof c!=="undefined"&&!c.event.triggered?c.event.handle.apply(o.elem,arguments):w};o.elem=a;b=b.split(" ");for(var k,n=0,r;k=b[n++];){j=e?c.extend({},e):{handler:d,data:f};if(k.indexOf(".")>-1){r=k.split(".");
-k=r.shift();j.namespace=r.slice(0).sort().join(".")}else{r=[];j.namespace=""}j.type=k;j.guid=d.guid;var u=i[k],z=c.event.special[k]||{};if(!u){u=i[k]=[];if(!z.setup||z.setup.call(a,f,r,o)===false)if(a.addEventListener)a.addEventListener(k,o,false);else a.attachEvent&&a.attachEvent("on"+k,o)}if(z.add){z.add.call(a,j);if(!j.handler.guid)j.handler.guid=d.guid}u.push(j);c.event.global[k]=true}a=null}}},global:{},remove:function(a,b,d,f){if(!(a.nodeType===3||a.nodeType===8)){var e,j=0,i,o,k,n,r,u,z=c.data(a),
-C=z&&z.events;if(z&&C){if(b&&b.type){d=b.handler;b=b.type}if(!b||typeof b==="string"&&b.charAt(0)==="."){b=b||"";for(e in C)c.event.remove(a,e+b)}else{for(b=b.split(" ");e=b[j++];){n=e;i=e.indexOf(".")<0;o=[];if(!i){o=e.split(".");e=o.shift();k=new RegExp("(^|\\.)"+c.map(o.slice(0).sort(),db).join("\\.(?:.*\\.)?")+"(\\.|$)")}if(r=C[e])if(d){n=c.event.special[e]||{};for(B=f||0;B<r.length;B++){u=r[B];if(d.guid===u.guid){if(i||k.test(u.namespace)){f==null&&r.splice(B--,1);n.remove&&n.remove.call(a,u)}if(f!=
-null)break}}if(r.length===0||f!=null&&r.length===1){if(!n.teardown||n.teardown.call(a,o)===false)Ca(a,e,z.handle);delete C[e]}}else for(var B=0;B<r.length;B++){u=r[B];if(i||k.test(u.namespace)){c.event.remove(a,n,u.handler,B);r.splice(B--,1)}}}if(c.isEmptyObject(C)){if(b=z.handle)b.elem=null;delete z.events;delete z.handle;c.isEmptyObject(z)&&c.removeData(a)}}}}},trigger:function(a,b,d,f){var e=a.type||a;if(!f){a=typeof a==="object"?a[G]?a:c.extend(c.Event(e),a):c.Event(e);if(e.indexOf("!")>=0){a.type=
-e=e.slice(0,-1);a.exclusive=true}if(!d){a.stopPropagation();c.event.global[e]&&c.each(c.cache,function(){this.events&&this.events[e]&&c.event.trigger(a,b,this.handle.elem)})}if(!d||d.nodeType===3||d.nodeType===8)return w;a.result=w;a.target=d;b=c.makeArray(b);b.unshift(a)}a.currentTarget=d;(f=c.data(d,"handle"))&&f.apply(d,b);f=d.parentNode||d.ownerDocument;try{if(!(d&&d.nodeName&&c.noData[d.nodeName.toLowerCase()]))if(d["on"+e]&&d["on"+e].apply(d,b)===false)a.result=false}catch(j){}if(!a.isPropagationStopped()&&
-f)c.event.trigger(a,b,f,true);else if(!a.isDefaultPrevented()){f=a.target;var i,o=c.nodeName(f,"a")&&e==="click",k=c.event.special[e]||{};if((!k._default||k._default.call(d,a)===false)&&!o&&!(f&&f.nodeName&&c.noData[f.nodeName.toLowerCase()])){try{if(f[e]){if(i=f["on"+e])f["on"+e]=null;c.event.triggered=true;f[e]()}}catch(n){}if(i)f["on"+e]=i;c.event.triggered=false}}},handle:function(a){var b,d,f,e;a=arguments[0]=c.event.fix(a||A.event);a.currentTarget=this;b=a.type.indexOf(".")<0&&!a.exclusive;
-if(!b){d=a.type.split(".");a.type=d.shift();f=new RegExp("(^|\\.)"+d.slice(0).sort().join("\\.(?:.*\\.)?")+"(\\.|$)")}e=c.data(this,"events");d=e[a.type];if(e&&d){d=d.slice(0);e=0;for(var j=d.length;e<j;e++){var i=d[e];if(b||f.test(i.namespace)){a.handler=i.handler;a.data=i.data;a.handleObj=i;i=i.handler.apply(this,arguments);if(i!==w){a.result=i;if(i===false){a.preventDefault();a.stopPropagation()}}if(a.isImmediatePropagationStopped())break}}}return a.result},props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
-fix:function(a){if(a[G])return a;var b=a;a=c.Event(b);for(var d=this.props.length,f;d;){f=this.props[--d];a[f]=b[f]}if(!a.target)a.target=a.srcElement||s;if(a.target.nodeType===3)a.target=a.target.parentNode;if(!a.relatedTarget&&a.fromElement)a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement;if(a.pageX==null&&a.clientX!=null){b=s.documentElement;d=s.body;a.pageX=a.clientX+(b&&b.scrollLeft||d&&d.scrollLeft||0)-(b&&b.clientLeft||d&&d.clientLeft||0);a.pageY=a.clientY+(b&&b.scrollTop||
-d&&d.scrollTop||0)-(b&&b.clientTop||d&&d.clientTop||0)}if(!a.which&&(a.charCode||a.charCode===0?a.charCode:a.keyCode))a.which=a.charCode||a.keyCode;if(!a.metaKey&&a.ctrlKey)a.metaKey=a.ctrlKey;if(!a.which&&a.button!==w)a.which=a.button&1?1:a.button&2?3:a.button&4?2:0;return a},guid:1E8,proxy:c.proxy,special:{ready:{setup:c.bindReady,teardown:c.noop},live:{add:function(a){c.event.add(this,a.origType,c.extend({},a,{handler:oa}))},remove:function(a){var b=true,d=a.origType.replace(O,"");c.each(c.data(this,
-"events").live||[],function(){if(d===this.origType.replace(O,""))return b=false});b&&c.event.remove(this,a.origType,oa)}},beforeunload:{setup:function(a,b,d){if(this.setInterval)this.onbeforeunload=d;return false},teardown:function(a,b){if(this.onbeforeunload===b)this.onbeforeunload=null}}}};var Ca=s.removeEventListener?function(a,b,d){a.removeEventListener(b,d,false)}:function(a,b,d){a.detachEvent("on"+b,d)};c.Event=function(a){if(!this.preventDefault)return new c.Event(a);if(a&&a.type){this.originalEvent=
-a;this.type=a.type}else this.type=a;this.timeStamp=J();this[G]=true};c.Event.prototype={preventDefault:function(){this.isDefaultPrevented=Z;var a=this.originalEvent;if(a){a.preventDefault&&a.preventDefault();a.returnValue=false}},stopPropagation:function(){this.isPropagationStopped=Z;var a=this.originalEvent;if(a){a.stopPropagation&&a.stopPropagation();a.cancelBubble=true}},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=Z;this.stopPropagation()},isDefaultPrevented:Y,isPropagationStopped:Y,
-isImmediatePropagationStopped:Y};var Da=function(a){var b=a.relatedTarget;try{for(;b&&b!==this;)b=b.parentNode;if(b!==this){a.type=a.data;c.event.handle.apply(this,arguments)}}catch(d){}},Ea=function(a){a.type=a.data;c.event.handle.apply(this,arguments)};c.each({mouseenter:"mouseover",mouseleave:"mouseout"},function(a,b){c.event.special[a]={setup:function(d){c.event.add(this,b,d&&d.selector?Ea:Da,a)},teardown:function(d){c.event.remove(this,b,d&&d.selector?Ea:Da)}}});if(!c.support.submitBubbles)c.event.special.submit=
-{setup:function(){if(this.nodeName.toLowerCase()!=="form"){c.event.add(this,"click.specialSubmit",function(a){var b=a.target,d=b.type;if((d==="submit"||d==="image")&&c(b).closest("form").length)return na("submit",this,arguments)});c.event.add(this,"keypress.specialSubmit",function(a){var b=a.target,d=b.type;if((d==="text"||d==="password")&&c(b).closest("form").length&&a.keyCode===13)return na("submit",this,arguments)})}else return false},teardown:function(){c.event.remove(this,".specialSubmit")}};
-if(!c.support.changeBubbles){var da=/textarea|input|select/i,ea,Fa=function(a){var b=a.type,d=a.value;if(b==="radio"||b==="checkbox")d=a.checked;else if(b==="select-multiple")d=a.selectedIndex>-1?c.map(a.options,function(f){return f.selected}).join("-"):"";else if(a.nodeName.toLowerCase()==="select")d=a.selectedIndex;return d},fa=function(a,b){var d=a.target,f,e;if(!(!da.test(d.nodeName)||d.readOnly)){f=c.data(d,"_change_data");e=Fa(d);if(a.type!=="focusout"||d.type!=="radio")c.data(d,"_change_data",
-e);if(!(f===w||e===f))if(f!=null||e){a.type="change";return c.event.trigger(a,b,d)}}};c.event.special.change={filters:{focusout:fa,click:function(a){var b=a.target,d=b.type;if(d==="radio"||d==="checkbox"||b.nodeName.toLowerCase()==="select")return fa.call(this,a)},keydown:function(a){var b=a.target,d=b.type;if(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(d==="checkbox"||d==="radio")||d==="select-multiple")return fa.call(this,a)},beforeactivate:function(a){a=a.target;c.data(a,
-"_change_data",Fa(a))}},setup:function(){if(this.type==="file")return false;for(var a in ea)c.event.add(this,a+".specialChange",ea[a]);return da.test(this.nodeName)},teardown:function(){c.event.remove(this,".specialChange");return da.test(this.nodeName)}};ea=c.event.special.change.filters}s.addEventListener&&c.each({focus:"focusin",blur:"focusout"},function(a,b){function d(f){f=c.event.fix(f);f.type=b;return c.event.handle.call(this,f)}c.event.special[b]={setup:function(){this.addEventListener(a,
-d,true)},teardown:function(){this.removeEventListener(a,d,true)}}});c.each(["bind","one"],function(a,b){c.fn[b]=function(d,f,e){if(typeof d==="object"){for(var j in d)this[b](j,f,d[j],e);return this}if(c.isFunction(f)){e=f;f=w}var i=b==="one"?c.proxy(e,function(k){c(this).unbind(k,i);return e.apply(this,arguments)}):e;if(d==="unload"&&b!=="one")this.one(d,f,e);else{j=0;for(var o=this.length;j<o;j++)c.event.add(this[j],d,i,f)}return this}});c.fn.extend({unbind:function(a,b){if(typeof a==="object"&&
-!a.preventDefault)for(var d in a)this.unbind(d,a[d]);else{d=0;for(var f=this.length;d<f;d++)c.event.remove(this[d],a,b)}return this},delegate:function(a,b,d,f){return this.live(b,d,f,a)},undelegate:function(a,b,d){return arguments.length===0?this.unbind("live"):this.die(b,null,d,a)},trigger:function(a,b){return this.each(function(){c.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0]){a=c.Event(a);a.preventDefault();a.stopPropagation();c.event.trigger(a,b,this[0]);return a.result}},
-toggle:function(a){for(var b=arguments,d=1;d<b.length;)c.proxy(a,b[d++]);return this.click(c.proxy(a,function(f){var e=(c.data(this,"lastToggle"+a.guid)||0)%d;c.data(this,"lastToggle"+a.guid,e+1);f.preventDefault();return b[e].apply(this,arguments)||false}))},hover:function(a,b){return this.mouseenter(a).mouseleave(b||a)}});var Ga={focus:"focusin",blur:"focusout",mouseenter:"mouseover",mouseleave:"mouseout"};c.each(["live","die"],function(a,b){c.fn[b]=function(d,f,e,j){var i,o=0,k,n,r=j||this.selector,
-u=j?this:c(this.context);if(c.isFunction(f)){e=f;f=w}for(d=(d||"").split(" ");(i=d[o++])!=null;){j=O.exec(i);k="";if(j){k=j[0];i=i.replace(O,"")}if(i==="hover")d.push("mouseenter"+k,"mouseleave"+k);else{n=i;if(i==="focus"||i==="blur"){d.push(Ga[i]+k);i+=k}else i=(Ga[i]||i)+k;b==="live"?u.each(function(){c.event.add(this,pa(i,r),{data:f,selector:r,handler:e,origType:i,origHandler:e,preType:n})}):u.unbind(pa(i,r),e)}}return this}});c.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),
-function(a,b){c.fn[b]=function(d){return d?this.bind(b,d):this.trigger(b)};if(c.attrFn)c.attrFn[b]=true});A.attachEvent&&!A.addEventListener&&A.attachEvent("onunload",function(){for(var a in c.cache)if(c.cache[a].handle)try{c.event.remove(c.cache[a].handle.elem)}catch(b){}});(function(){function a(g){for(var h="",l,m=0;g[m];m++){l=g[m];if(l.nodeType===3||l.nodeType===4)h+=l.nodeValue;else if(l.nodeType!==8)h+=a(l.childNodes)}return h}function b(g,h,l,m,q,p){q=0;for(var v=m.length;q<v;q++){var t=m[q];
-if(t){t=t[g];for(var y=false;t;){if(t.sizcache===l){y=m[t.sizset];break}if(t.nodeType===1&&!p){t.sizcache=l;t.sizset=q}if(t.nodeName.toLowerCase()===h){y=t;break}t=t[g]}m[q]=y}}}function d(g,h,l,m,q,p){q=0;for(var v=m.length;q<v;q++){var t=m[q];if(t){t=t[g];for(var y=false;t;){if(t.sizcache===l){y=m[t.sizset];break}if(t.nodeType===1){if(!p){t.sizcache=l;t.sizset=q}if(typeof h!=="string"){if(t===h){y=true;break}}else if(k.filter(h,[t]).length>0){y=t;break}}t=t[g]}m[q]=y}}}var f=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
-e=0,j=Object.prototype.toString,i=false,o=true;[0,0].sort(function(){o=false;return 0});var k=function(g,h,l,m){l=l||[];var q=h=h||s;if(h.nodeType!==1&&h.nodeType!==9)return[];if(!g||typeof g!=="string")return l;for(var p=[],v,t,y,S,H=true,M=x(h),I=g;(f.exec(""),v=f.exec(I))!==null;){I=v[3];p.push(v[1]);if(v[2]){S=v[3];break}}if(p.length>1&&r.exec(g))if(p.length===2&&n.relative[p[0]])t=ga(p[0]+p[1],h);else for(t=n.relative[p[0]]?[h]:k(p.shift(),h);p.length;){g=p.shift();if(n.relative[g])g+=p.shift();
-t=ga(g,t)}else{if(!m&&p.length>1&&h.nodeType===9&&!M&&n.match.ID.test(p[0])&&!n.match.ID.test(p[p.length-1])){v=k.find(p.shift(),h,M);h=v.expr?k.filter(v.expr,v.set)[0]:v.set[0]}if(h){v=m?{expr:p.pop(),set:z(m)}:k.find(p.pop(),p.length===1&&(p[0]==="~"||p[0]==="+")&&h.parentNode?h.parentNode:h,M);t=v.expr?k.filter(v.expr,v.set):v.set;if(p.length>0)y=z(t);else H=false;for(;p.length;){var D=p.pop();v=D;if(n.relative[D])v=p.pop();else D="";if(v==null)v=h;n.relative[D](y,v,M)}}else y=[]}y||(y=t);y||k.error(D||
-g);if(j.call(y)==="[object Array]")if(H)if(h&&h.nodeType===1)for(g=0;y[g]!=null;g++){if(y[g]&&(y[g]===true||y[g].nodeType===1&&E(h,y[g])))l.push(t[g])}else for(g=0;y[g]!=null;g++)y[g]&&y[g].nodeType===1&&l.push(t[g]);else l.push.apply(l,y);else z(y,l);if(S){k(S,q,l,m);k.uniqueSort(l)}return l};k.uniqueSort=function(g){if(B){i=o;g.sort(B);if(i)for(var h=1;h<g.length;h++)g[h]===g[h-1]&&g.splice(h--,1)}return g};k.matches=function(g,h){return k(g,null,null,h)};k.find=function(g,h,l){var m,q;if(!g)return[];
-for(var p=0,v=n.order.length;p<v;p++){var t=n.order[p];if(q=n.leftMatch[t].exec(g)){var y=q[1];q.splice(1,1);if(y.substr(y.length-1)!=="\\"){q[1]=(q[1]||"").replace(/\\/g,"");m=n.find[t](q,h,l);if(m!=null){g=g.replace(n.match[t],"");break}}}}m||(m=h.getElementsByTagName("*"));return{set:m,expr:g}};k.filter=function(g,h,l,m){for(var q=g,p=[],v=h,t,y,S=h&&h[0]&&x(h[0]);g&&h.length;){for(var H in n.filter)if((t=n.leftMatch[H].exec(g))!=null&&t[2]){var M=n.filter[H],I,D;D=t[1];y=false;t.splice(1,1);if(D.substr(D.length-
-1)!=="\\"){if(v===p)p=[];if(n.preFilter[H])if(t=n.preFilter[H](t,v,l,p,m,S)){if(t===true)continue}else y=I=true;if(t)for(var U=0;(D=v[U])!=null;U++)if(D){I=M(D,t,U,v);var Ha=m^!!I;if(l&&I!=null)if(Ha)y=true;else v[U]=false;else if(Ha){p.push(D);y=true}}if(I!==w){l||(v=p);g=g.replace(n.match[H],"");if(!y)return[];break}}}if(g===q)if(y==null)k.error(g);else break;q=g}return v};k.error=function(g){throw"Syntax error, unrecognized expression: "+g;};var n=k.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
-CLASS:/\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(g){return g.getAttribute("href")}},
-relative:{"+":function(g,h){var l=typeof h==="string",m=l&&!/\W/.test(h);l=l&&!m;if(m)h=h.toLowerCase();m=0;for(var q=g.length,p;m<q;m++)if(p=g[m]){for(;(p=p.previousSibling)&&p.nodeType!==1;);g[m]=l||p&&p.nodeName.toLowerCase()===h?p||false:p===h}l&&k.filter(h,g,true)},">":function(g,h){var l=typeof h==="string";if(l&&!/\W/.test(h)){h=h.toLowerCase();for(var m=0,q=g.length;m<q;m++){var p=g[m];if(p){l=p.parentNode;g[m]=l.nodeName.toLowerCase()===h?l:false}}}else{m=0;for(q=g.length;m<q;m++)if(p=g[m])g[m]=
-l?p.parentNode:p.parentNode===h;l&&k.filter(h,g,true)}},"":function(g,h,l){var m=e++,q=d;if(typeof h==="string"&&!/\W/.test(h)){var p=h=h.toLowerCase();q=b}q("parentNode",h,m,g,p,l)},"~":function(g,h,l){var m=e++,q=d;if(typeof h==="string"&&!/\W/.test(h)){var p=h=h.toLowerCase();q=b}q("previousSibling",h,m,g,p,l)}},find:{ID:function(g,h,l){if(typeof h.getElementById!=="undefined"&&!l)return(g=h.getElementById(g[1]))?[g]:[]},NAME:function(g,h){if(typeof h.getElementsByName!=="undefined"){var l=[];
-h=h.getElementsByName(g[1]);for(var m=0,q=h.length;m<q;m++)h[m].getAttribute("name")===g[1]&&l.push(h[m]);return l.length===0?null:l}},TAG:function(g,h){return h.getElementsByTagName(g[1])}},preFilter:{CLASS:function(g,h,l,m,q,p){g=" "+g[1].replace(/\\/g,"")+" ";if(p)return g;p=0;for(var v;(v=h[p])!=null;p++)if(v)if(q^(v.className&&(" "+v.className+" ").replace(/[\t\n]/g," ").indexOf(g)>=0))l||m.push(v);else if(l)h[p]=false;return false},ID:function(g){return g[1].replace(/\\/g,"")},TAG:function(g){return g[1].toLowerCase()},
-CHILD:function(g){if(g[1]==="nth"){var h=/(-?)(\d*)n((?:\+|-)?\d*)/.exec(g[2]==="even"&&"2n"||g[2]==="odd"&&"2n+1"||!/\D/.test(g[2])&&"0n+"+g[2]||g[2]);g[2]=h[1]+(h[2]||1)-0;g[3]=h[3]-0}g[0]=e++;return g},ATTR:function(g,h,l,m,q,p){h=g[1].replace(/\\/g,"");if(!p&&n.attrMap[h])g[1]=n.attrMap[h];if(g[2]==="~=")g[4]=" "+g[4]+" ";return g},PSEUDO:function(g,h,l,m,q){if(g[1]==="not")if((f.exec(g[3])||"").length>1||/^\w/.test(g[3]))g[3]=k(g[3],null,null,h);else{g=k.filter(g[3],h,l,true^q);l||m.push.apply(m,
-g);return false}else if(n.match.POS.test(g[0])||n.match.CHILD.test(g[0]))return true;return g},POS:function(g){g.unshift(true);return g}},filters:{enabled:function(g){return g.disabled===false&&g.type!=="hidden"},disabled:function(g){return g.disabled===true},checked:function(g){return g.checked===true},selected:function(g){return g.selected===true},parent:function(g){return!!g.firstChild},empty:function(g){return!g.firstChild},has:function(g,h,l){return!!k(l[3],g).length},header:function(g){return/h\d/i.test(g.nodeName)},
-text:function(g){return"text"===g.type},radio:function(g){return"radio"===g.type},checkbox:function(g){return"checkbox"===g.type},file:function(g){return"file"===g.type},password:function(g){return"password"===g.type},submit:function(g){return"submit"===g.type},image:function(g){return"image"===g.type},reset:function(g){return"reset"===g.type},button:function(g){return"button"===g.type||g.nodeName.toLowerCase()==="button"},input:function(g){return/input|select|textarea|button/i.test(g.nodeName)}},
-setFilters:{first:function(g,h){return h===0},last:function(g,h,l,m){return h===m.length-1},even:function(g,h){return h%2===0},odd:function(g,h){return h%2===1},lt:function(g,h,l){return h<l[3]-0},gt:function(g,h,l){return h>l[3]-0},nth:function(g,h,l){return l[3]-0===h},eq:function(g,h,l){return l[3]-0===h}},filter:{PSEUDO:function(g,h,l,m){var q=h[1],p=n.filters[q];if(p)return p(g,l,h,m);else if(q==="contains")return(g.textContent||g.innerText||a([g])||"").indexOf(h[3])>=0;else if(q==="not"){h=
-h[3];l=0;for(m=h.length;l<m;l++)if(h[l]===g)return false;return true}else k.error("Syntax error, unrecognized expression: "+q)},CHILD:function(g,h){var l=h[1],m=g;switch(l){case "only":case "first":for(;m=m.previousSibling;)if(m.nodeType===1)return false;if(l==="first")return true;m=g;case "last":for(;m=m.nextSibling;)if(m.nodeType===1)return false;return true;case "nth":l=h[2];var q=h[3];if(l===1&&q===0)return true;h=h[0];var p=g.parentNode;if(p&&(p.sizcache!==h||!g.nodeIndex)){var v=0;for(m=p.firstChild;m;m=
-m.nextSibling)if(m.nodeType===1)m.nodeIndex=++v;p.sizcache=h}g=g.nodeIndex-q;return l===0?g===0:g%l===0&&g/l>=0}},ID:function(g,h){return g.nodeType===1&&g.getAttribute("id")===h},TAG:function(g,h){return h==="*"&&g.nodeType===1||g.nodeName.toLowerCase()===h},CLASS:function(g,h){return(" "+(g.className||g.getAttribute("class"))+" ").indexOf(h)>-1},ATTR:function(g,h){var l=h[1];g=n.attrHandle[l]?n.attrHandle[l](g):g[l]!=null?g[l]:g.getAttribute(l);l=g+"";var m=h[2];h=h[4];return g==null?m==="!=":m===
-"="?l===h:m==="*="?l.indexOf(h)>=0:m==="~="?(" "+l+" ").indexOf(h)>=0:!h?l&&g!==false:m==="!="?l!==h:m==="^="?l.indexOf(h)===0:m==="$="?l.substr(l.length-h.length)===h:m==="|="?l===h||l.substr(0,h.length+1)===h+"-":false},POS:function(g,h,l,m){var q=n.setFilters[h[2]];if(q)return q(g,l,h,m)}}},r=n.match.POS;for(var u in n.match){n.match[u]=new RegExp(n.match[u].source+/(?![^\[]*\])(?![^\(]*\))/.source);n.leftMatch[u]=new RegExp(/(^(?:.|\r|\n)*?)/.source+n.match[u].source.replace(/\\(\d+)/g,function(g,
-h){return"\\"+(h-0+1)}))}var z=function(g,h){g=Array.prototype.slice.call(g,0);if(h){h.push.apply(h,g);return h}return g};try{Array.prototype.slice.call(s.documentElement.childNodes,0)}catch(C){z=function(g,h){h=h||[];if(j.call(g)==="[object Array]")Array.prototype.push.apply(h,g);else if(typeof g.length==="number")for(var l=0,m=g.length;l<m;l++)h.push(g[l]);else for(l=0;g[l];l++)h.push(g[l]);return h}}var B;if(s.documentElement.compareDocumentPosition)B=function(g,h){if(!g.compareDocumentPosition||
-!h.compareDocumentPosition){if(g==h)i=true;return g.compareDocumentPosition?-1:1}g=g.compareDocumentPosition(h)&4?-1:g===h?0:1;if(g===0)i=true;return g};else if("sourceIndex"in s.documentElement)B=function(g,h){if(!g.sourceIndex||!h.sourceIndex){if(g==h)i=true;return g.sourceIndex?-1:1}g=g.sourceIndex-h.sourceIndex;if(g===0)i=true;return g};else if(s.createRange)B=function(g,h){if(!g.ownerDocument||!h.ownerDocument){if(g==h)i=true;return g.ownerDocument?-1:1}var l=g.ownerDocument.createRange(),m=
-h.ownerDocument.createRange();l.setStart(g,0);l.setEnd(g,0);m.setStart(h,0);m.setEnd(h,0);g=l.compareBoundaryPoints(Range.START_TO_END,m);if(g===0)i=true;return g};(function(){var g=s.createElement("div"),h="script"+(new Date).getTime();g.innerHTML="<a name='"+h+"'/>";var l=s.documentElement;l.insertBefore(g,l.firstChild);if(s.getElementById(h)){n.find.ID=function(m,q,p){if(typeof q.getElementById!=="undefined"&&!p)return(q=q.getElementById(m[1]))?q.id===m[1]||typeof q.getAttributeNode!=="undefined"&&
-q.getAttributeNode("id").nodeValue===m[1]?[q]:w:[]};n.filter.ID=function(m,q){var p=typeof m.getAttributeNode!=="undefined"&&m.getAttributeNode("id");return m.nodeType===1&&p&&p.nodeValue===q}}l.removeChild(g);l=g=null})();(function(){var g=s.createElement("div");g.appendChild(s.createComment(""));if(g.getElementsByTagName("*").length>0)n.find.TAG=function(h,l){l=l.getElementsByTagName(h[1]);if(h[1]==="*"){h=[];for(var m=0;l[m];m++)l[m].nodeType===1&&h.push(l[m]);l=h}return l};g.innerHTML="<a href='#'></a>";
-if(g.firstChild&&typeof g.firstChild.getAttribute!=="undefined"&&g.firstChild.getAttribute("href")!=="#")n.attrHandle.href=function(h){return h.getAttribute("href",2)};g=null})();s.querySelectorAll&&function(){var g=k,h=s.createElement("div");h.innerHTML="<p class='TEST'></p>";if(!(h.querySelectorAll&&h.querySelectorAll(".TEST").length===0)){k=function(m,q,p,v){q=q||s;if(!v&&q.nodeType===9&&!x(q))try{return z(q.querySelectorAll(m),p)}catch(t){}return g(m,q,p,v)};for(var l in g)k[l]=g[l];h=null}}();
-(function(){var g=s.createElement("div");g.innerHTML="<div class='test e'></div><div class='test'></div>";if(!(!g.getElementsByClassName||g.getElementsByClassName("e").length===0)){g.lastChild.className="e";if(g.getElementsByClassName("e").length!==1){n.order.splice(1,0,"CLASS");n.find.CLASS=function(h,l,m){if(typeof l.getElementsByClassName!=="undefined"&&!m)return l.getElementsByClassName(h[1])};g=null}}})();var E=s.compareDocumentPosition?function(g,h){return!!(g.compareDocumentPosition(h)&16)}:
-function(g,h){return g!==h&&(g.contains?g.contains(h):true)},x=function(g){return(g=(g?g.ownerDocument||g:0).documentElement)?g.nodeName!=="HTML":false},ga=function(g,h){var l=[],m="",q;for(h=h.nodeType?[h]:h;q=n.match.PSEUDO.exec(g);){m+=q[0];g=g.replace(n.match.PSEUDO,"")}g=n.relative[g]?g+"*":g;q=0;for(var p=h.length;q<p;q++)k(g,h[q],l);return k.filter(m,l)};c.find=k;c.expr=k.selectors;c.expr[":"]=c.expr.filters;c.unique=k.uniqueSort;c.text=a;c.isXMLDoc=x;c.contains=E})();var eb=/Until$/,fb=/^(?:parents|prevUntil|prevAll)/,
-gb=/,/;R=Array.prototype.slice;var Ia=function(a,b,d){if(c.isFunction(b))return c.grep(a,function(e,j){return!!b.call(e,j,e)===d});else if(b.nodeType)return c.grep(a,function(e){return e===b===d});else if(typeof b==="string"){var f=c.grep(a,function(e){return e.nodeType===1});if(Ua.test(b))return c.filter(b,f,!d);else b=c.filter(b,f)}return c.grep(a,function(e){return c.inArray(e,b)>=0===d})};c.fn.extend({find:function(a){for(var b=this.pushStack("","find",a),d=0,f=0,e=this.length;f<e;f++){d=b.length;
-c.find(a,this[f],b);if(f>0)for(var j=d;j<b.length;j++)for(var i=0;i<d;i++)if(b[i]===b[j]){b.splice(j--,1);break}}return b},has:function(a){var b=c(a);return this.filter(function(){for(var d=0,f=b.length;d<f;d++)if(c.contains(this,b[d]))return true})},not:function(a){return this.pushStack(Ia(this,a,false),"not",a)},filter:function(a){return this.pushStack(Ia(this,a,true),"filter",a)},is:function(a){return!!a&&c.filter(a,this).length>0},closest:function(a,b){if(c.isArray(a)){var d=[],f=this[0],e,j=
-{},i;if(f&&a.length){e=0;for(var o=a.length;e<o;e++){i=a[e];j[i]||(j[i]=c.expr.match.POS.test(i)?c(i,b||this.context):i)}for(;f&&f.ownerDocument&&f!==b;){for(i in j){e=j[i];if(e.jquery?e.index(f)>-1:c(f).is(e)){d.push({selector:i,elem:f});delete j[i]}}f=f.parentNode}}return d}var k=c.expr.match.POS.test(a)?c(a,b||this.context):null;return this.map(function(n,r){for(;r&&r.ownerDocument&&r!==b;){if(k?k.index(r)>-1:c(r).is(a))return r;r=r.parentNode}return null})},index:function(a){if(!a||typeof a===
-"string")return c.inArray(this[0],a?c(a):this.parent().children());return c.inArray(a.jquery?a[0]:a,this)},add:function(a,b){a=typeof a==="string"?c(a,b||this.context):c.makeArray(a);b=c.merge(this.get(),a);return this.pushStack(qa(a[0])||qa(b[0])?b:c.unique(b))},andSelf:function(){return this.add(this.prevObject)}});c.each({parent:function(a){return(a=a.parentNode)&&a.nodeType!==11?a:null},parents:function(a){return c.dir(a,"parentNode")},parentsUntil:function(a,b,d){return c.dir(a,"parentNode",
-d)},next:function(a){return c.nth(a,2,"nextSibling")},prev:function(a){return c.nth(a,2,"previousSibling")},nextAll:function(a){return c.dir(a,"nextSibling")},prevAll:function(a){return c.dir(a,"previousSibling")},nextUntil:function(a,b,d){return c.dir(a,"nextSibling",d)},prevUntil:function(a,b,d){return c.dir(a,"previousSibling",d)},siblings:function(a){return c.sibling(a.parentNode.firstChild,a)},children:function(a){return c.sibling(a.firstChild)},contents:function(a){return c.nodeName(a,"iframe")?
-a.contentDocument||a.contentWindow.document:c.makeArray(a.childNodes)}},function(a,b){c.fn[a]=function(d,f){var e=c.map(this,b,d);eb.test(a)||(f=d);if(f&&typeof f==="string")e=c.filter(f,e);e=this.length>1?c.unique(e):e;if((this.length>1||gb.test(f))&&fb.test(a))e=e.reverse();return this.pushStack(e,a,R.call(arguments).join(","))}});c.extend({filter:function(a,b,d){if(d)a=":not("+a+")";return c.find.matches(a,b)},dir:function(a,b,d){var f=[];for(a=a[b];a&&a.nodeType!==9&&(d===w||a.nodeType!==1||!c(a).is(d));){a.nodeType===
-1&&f.push(a);a=a[b]}return f},nth:function(a,b,d){b=b||1;for(var f=0;a;a=a[d])if(a.nodeType===1&&++f===b)break;return a},sibling:function(a,b){for(var d=[];a;a=a.nextSibling)a.nodeType===1&&a!==b&&d.push(a);return d}});var Ja=/ jQuery\d+="(?:\d+|null)"/g,V=/^\s+/,Ka=/(<([\w:]+)[^>]*?)\/>/g,hb=/^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,La=/<([\w:]+)/,ib=/<tbody/i,jb=/<|&#?\w+;/,ta=/<script|<object|<embed|<option|<style/i,ua=/checked\s*(?:[^=]|=\s*.checked.)/i,Ma=function(a,b,d){return hb.test(d)?
-a:b+"></"+d+">"},F={option:[1,"<select multiple='multiple'>","</select>"],legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};F.optgroup=F.option;F.tbody=F.tfoot=F.colgroup=F.caption=F.thead;F.th=F.td;if(!c.support.htmlSerialize)F._default=[1,"div<div>","</div>"];c.fn.extend({text:function(a){if(c.isFunction(a))return this.each(function(b){var d=
-c(this);d.text(a.call(this,b,d.text()))});if(typeof a!=="object"&&a!==w)return this.empty().append((this[0]&&this[0].ownerDocument||s).createTextNode(a));return c.text(this)},wrapAll:function(a){if(c.isFunction(a))return this.each(function(d){c(this).wrapAll(a.call(this,d))});if(this[0]){var b=c(a,this[0].ownerDocument).eq(0).clone(true);this[0].parentNode&&b.insertBefore(this[0]);b.map(function(){for(var d=this;d.firstChild&&d.firstChild.nodeType===1;)d=d.firstChild;return d}).append(this)}return this},
-wrapInner:function(a){if(c.isFunction(a))return this.each(function(b){c(this).wrapInner(a.call(this,b))});return this.each(function(){var b=c(this),d=b.contents();d.length?d.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){c(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){c.nodeName(this,"body")||c(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.appendChild(a)})},
-prepend:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this)});else if(arguments.length){var a=c(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,
-this.nextSibling)});else if(arguments.length){var a=this.pushStack(this,"after",arguments);a.push.apply(a,c(arguments[0]).toArray());return a}},remove:function(a,b){for(var d=0,f;(f=this[d])!=null;d++)if(!a||c.filter(a,[f]).length){if(!b&&f.nodeType===1){c.cleanData(f.getElementsByTagName("*"));c.cleanData([f])}f.parentNode&&f.parentNode.removeChild(f)}return this},empty:function(){for(var a=0,b;(b=this[a])!=null;a++)for(b.nodeType===1&&c.cleanData(b.getElementsByTagName("*"));b.firstChild;)b.removeChild(b.firstChild);
-return this},clone:function(a){var b=this.map(function(){if(!c.support.noCloneEvent&&!c.isXMLDoc(this)){var d=this.outerHTML,f=this.ownerDocument;if(!d){d=f.createElement("div");d.appendChild(this.cloneNode(true));d=d.innerHTML}return c.clean([d.replace(Ja,"").replace(/=([^="'>\s]+\/)>/g,'="$1">').replace(V,"")],f)[0]}else return this.cloneNode(true)});if(a===true){ra(this,b);ra(this.find("*"),b.find("*"))}return b},html:function(a){if(a===w)return this[0]&&this[0].nodeType===1?this[0].innerHTML.replace(Ja,
-""):null;else if(typeof a==="string"&&!ta.test(a)&&(c.support.leadingWhitespace||!V.test(a))&&!F[(La.exec(a)||["",""])[1].toLowerCase()]){a=a.replace(Ka,Ma);try{for(var b=0,d=this.length;b<d;b++)if(this[b].nodeType===1){c.cleanData(this[b].getElementsByTagName("*"));this[b].innerHTML=a}}catch(f){this.empty().append(a)}}else c.isFunction(a)?this.each(function(e){var j=c(this),i=j.html();j.empty().append(function(){return a.call(this,e,i)})}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&
-this[0].parentNode){if(c.isFunction(a))return this.each(function(b){var d=c(this),f=d.html();d.replaceWith(a.call(this,b,f))});if(typeof a!=="string")a=c(a).detach();return this.each(function(){var b=this.nextSibling,d=this.parentNode;c(this).remove();b?c(b).before(a):c(d).append(a)})}else return this.pushStack(c(c.isFunction(a)?a():a),"replaceWith",a)},detach:function(a){return this.remove(a,true)},domManip:function(a,b,d){function f(u){return c.nodeName(u,"table")?u.getElementsByTagName("tbody")[0]||
-u.appendChild(u.ownerDocument.createElement("tbody")):u}var e,j,i=a[0],o=[],k;if(!c.support.checkClone&&arguments.length===3&&typeof i==="string"&&ua.test(i))return this.each(function(){c(this).domManip(a,b,d,true)});if(c.isFunction(i))return this.each(function(u){var z=c(this);a[0]=i.call(this,u,b?z.html():w);z.domManip(a,b,d)});if(this[0]){e=i&&i.parentNode;e=c.support.parentNode&&e&&e.nodeType===11&&e.childNodes.length===this.length?{fragment:e}:sa(a,this,o);k=e.fragment;if(j=k.childNodes.length===
-1?(k=k.firstChild):k.firstChild){b=b&&c.nodeName(j,"tr");for(var n=0,r=this.length;n<r;n++)d.call(b?f(this[n],j):this[n],n>0||e.cacheable||this.length>1?k.cloneNode(true):k)}o.length&&c.each(o,Qa)}return this}});c.fragments={};c.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},function(a,b){c.fn[a]=function(d){var f=[];d=c(d);var e=this.length===1&&this[0].parentNode;if(e&&e.nodeType===11&&e.childNodes.length===1&&d.length===1){d[b](this[0]);
-return this}else{e=0;for(var j=d.length;e<j;e++){var i=(e>0?this.clone(true):this).get();c.fn[b].apply(c(d[e]),i);f=f.concat(i)}return this.pushStack(f,a,d.selector)}}});c.extend({clean:function(a,b,d,f){b=b||s;if(typeof b.createElement==="undefined")b=b.ownerDocument||b[0]&&b[0].ownerDocument||s;for(var e=[],j=0,i;(i=a[j])!=null;j++){if(typeof i==="number")i+="";if(i){if(typeof i==="string"&&!jb.test(i))i=b.createTextNode(i);else if(typeof i==="string"){i=i.replace(Ka,Ma);var o=(La.exec(i)||["",
-""])[1].toLowerCase(),k=F[o]||F._default,n=k[0],r=b.createElement("div");for(r.innerHTML=k[1]+i+k[2];n--;)r=r.lastChild;if(!c.support.tbody){n=ib.test(i);o=o==="table"&&!n?r.firstChild&&r.firstChild.childNodes:k[1]==="<table>"&&!n?r.childNodes:[];for(k=o.length-1;k>=0;--k)c.nodeName(o[k],"tbody")&&!o[k].childNodes.length&&o[k].parentNode.removeChild(o[k])}!c.support.leadingWhitespace&&V.test(i)&&r.insertBefore(b.createTextNode(V.exec(i)[0]),r.firstChild);i=r.childNodes}if(i.nodeType)e.push(i);else e=
-c.merge(e,i)}}if(d)for(j=0;e[j];j++)if(f&&c.nodeName(e[j],"script")&&(!e[j].type||e[j].type.toLowerCase()==="text/javascript"))f.push(e[j].parentNode?e[j].parentNode.removeChild(e[j]):e[j]);else{e[j].nodeType===1&&e.splice.apply(e,[j+1,0].concat(c.makeArray(e[j].getElementsByTagName("script"))));d.appendChild(e[j])}return e},cleanData:function(a){for(var b,d,f=c.cache,e=c.event.special,j=c.support.deleteExpando,i=0,o;(o=a[i])!=null;i++)if(d=o[c.expando]){b=f[d];if(b.events)for(var k in b.events)e[k]?
-c.event.remove(o,k):Ca(o,k,b.handle);if(j)delete o[c.expando];else o.removeAttribute&&o.removeAttribute(c.expando);delete f[d]}}});var kb=/z-?index|font-?weight|opacity|zoom|line-?height/i,Na=/alpha\([^)]*\)/,Oa=/opacity=([^)]*)/,ha=/float/i,ia=/-([a-z])/ig,lb=/([A-Z])/g,mb=/^-?\d+(?:px)?$/i,nb=/^-?\d/,ob={position:"absolute",visibility:"hidden",display:"block"},pb=["Left","Right"],qb=["Top","Bottom"],rb=s.defaultView&&s.defaultView.getComputedStyle,Pa=c.support.cssFloat?"cssFloat":"styleFloat",ja=
-function(a,b){return b.toUpperCase()};c.fn.css=function(a,b){return X(this,a,b,true,function(d,f,e){if(e===w)return c.curCSS(d,f);if(typeof e==="number"&&!kb.test(f))e+="px";c.style(d,f,e)})};c.extend({style:function(a,b,d){if(!a||a.nodeType===3||a.nodeType===8)return w;if((b==="width"||b==="height")&&parseFloat(d)<0)d=w;var f=a.style||a,e=d!==w;if(!c.support.opacity&&b==="opacity"){if(e){f.zoom=1;b=parseInt(d,10)+""==="NaN"?"":"alpha(opacity="+d*100+")";a=f.filter||c.curCSS(a,"filter")||"";f.filter=
-Na.test(a)?a.replace(Na,b):b}return f.filter&&f.filter.indexOf("opacity=")>=0?parseFloat(Oa.exec(f.filter)[1])/100+"":""}if(ha.test(b))b=Pa;b=b.replace(ia,ja);if(e)f[b]=d;return f[b]},css:function(a,b,d,f){if(b==="width"||b==="height"){var e,j=b==="width"?pb:qb;function i(){e=b==="width"?a.offsetWidth:a.offsetHeight;f!=="border"&&c.each(j,function(){f||(e-=parseFloat(c.curCSS(a,"padding"+this,true))||0);if(f==="margin")e+=parseFloat(c.curCSS(a,"margin"+this,true))||0;else e-=parseFloat(c.curCSS(a,
-"border"+this+"Width",true))||0})}a.offsetWidth!==0?i():c.swap(a,ob,i);return Math.max(0,Math.round(e))}return c.curCSS(a,b,d)},curCSS:function(a,b,d){var f,e=a.style;if(!c.support.opacity&&b==="opacity"&&a.currentStyle){f=Oa.test(a.currentStyle.filter||"")?parseFloat(RegExp.$1)/100+"":"";return f===""?"1":f}if(ha.test(b))b=Pa;if(!d&&e&&e[b])f=e[b];else if(rb){if(ha.test(b))b="float";b=b.replace(lb,"-$1").toLowerCase();e=a.ownerDocument.defaultView;if(!e)return null;if(a=e.getComputedStyle(a,null))f=
-a.getPropertyValue(b);if(b==="opacity"&&f==="")f="1"}else if(a.currentStyle){d=b.replace(ia,ja);f=a.currentStyle[b]||a.currentStyle[d];if(!mb.test(f)&&nb.test(f)){b=e.left;var j=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;e.left=d==="fontSize"?"1em":f||0;f=e.pixelLeft+"px";e.left=b;a.runtimeStyle.left=j}}return f},swap:function(a,b,d){var f={};for(var e in b){f[e]=a.style[e];a.style[e]=b[e]}d.call(a);for(e in b)a.style[e]=f[e]}});if(c.expr&&c.expr.filters){c.expr.filters.hidden=function(a){var b=
-a.offsetWidth,d=a.offsetHeight,f=a.nodeName.toLowerCase()==="tr";return b===0&&d===0&&!f?true:b>0&&d>0&&!f?false:c.curCSS(a,"display")==="none"};c.expr.filters.visible=function(a){return!c.expr.filters.hidden(a)}}var sb=J(),tb=/<script(.|\s)*?\/script>/gi,ub=/select|textarea/i,vb=/color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,N=/=\?(&|$)/,ka=/\?/,wb=/(\?|&)_=.*?(&|$)/,xb=/^(\w+:)?\/\/([^\/?#]+)/,yb=/%20/g,zb=c.fn.load;c.fn.extend({load:function(a,b,d){if(typeof a!==
-"string")return zb.call(this,a);else if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var e=a.slice(f,a.length);a=a.slice(0,f)}f="GET";if(b)if(c.isFunction(b)){d=b;b=null}else if(typeof b==="object"){b=c.param(b,c.ajaxSettings.traditional);f="POST"}var j=this;c.ajax({url:a,type:f,dataType:"html",data:b,complete:function(i,o){if(o==="success"||o==="notmodified")j.html(e?c("<div />").append(i.responseText.replace(tb,"")).find(e):i.responseText);d&&j.each(d,[i.responseText,o,i])}});return this},
-serialize:function(){return c.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?c.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||ub.test(this.nodeName)||vb.test(this.type))}).map(function(a,b){a=c(this).val();return a==null?null:c.isArray(a)?c.map(a,function(d){return{name:b.name,value:d}}):{name:b.name,value:a}}).get()}});c.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),
-function(a,b){c.fn[b]=function(d){return this.bind(b,d)}});c.extend({get:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b=null}return c.ajax({type:"GET",url:a,data:b,success:d,dataType:f})},getScript:function(a,b){return c.get(a,null,b,"script")},getJSON:function(a,b,d){return c.get(a,b,d,"json")},post:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b={}}return c.ajax({type:"POST",url:a,data:b,success:d,dataType:f})},ajaxSetup:function(a){c.extend(c.ajaxSettings,a)},ajaxSettings:{url:location.href,
-global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,xhr:A.XMLHttpRequest&&(A.location.protocol!=="file:"||!A.ActiveXObject)?function(){return new A.XMLHttpRequest}:function(){try{return new A.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}},accepts:{xml:"application/xml, text/xml",html:"text/html",script:"text/javascript, application/javascript",json:"application/json, text/javascript",text:"text/plain",_default:"*/*"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&&
-e.success.call(k,o,i,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(k,x,i);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(q,p){(e.context?c(e.context):c.event).trigger(q,p)}var e=c.extend(true,{},c.ajaxSettings,a),j,i,o,k=a&&a.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,e.traditional);if(e.dataType==="jsonp"){if(n==="GET")N.test(e.url)||(e.url+=(ka.test(e.url)?
-"&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!N.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&N.test(e.data)||N.test(e.url))){j=e.jsonpCallback||"jsonp"+sb++;if(e.data)e.data=(e.data+"").replace(N,"="+j+"$1");e.url=e.url.replace(N,"="+j+"$1");e.dataType="script";A[j]=A[j]||function(q){o=q;b();d();A[j]=w;try{delete A[j]}catch(p){}z&&z.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache===
-false&&n==="GET"){var r=J(),u=e.url.replace(wb,"$1_="+r+"$2");e.url=u+(u===e.url?(ka.test(e.url)?"&":"?")+"_="+r:"")}if(e.data&&n==="GET")e.url+=(ka.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");r=(r=xb.exec(e.url))&&(r[1]&&r[1]!==location.protocol||r[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&r){var z=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!j){var B=
-false;C.onload=C.onreadystatechange=function(){if(!B&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){B=true;b();d();C.onload=C.onreadystatechange=null;z&&C.parentNode&&z.removeChild(C)}}}z.insertBefore(C,z.firstChild);return w}var E=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since",
-c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}r||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+", */*":e.accepts._default)}catch(ga){}if(e.beforeSend&&e.beforeSend.call(k,x,e)===false){e.global&&!--c.active&&c.event.trigger("ajaxStop");x.abort();return false}e.global&&f("ajaxSend",[x,e]);var g=x.onreadystatechange=function(q){if(!x||x.readyState===0||q==="abort"){E||
-d();E=true;if(x)x.onreadystatechange=c.noop}else if(!E&&x&&(x.readyState===4||q==="timeout")){E=true;x.onreadystatechange=c.noop;i=q==="timeout"?"timeout":!c.httpSuccess(x)?"error":e.ifModified&&c.httpNotModified(x,e.url)?"notmodified":"success";var p;if(i==="success")try{o=c.httpData(x,e.dataType,e)}catch(v){i="parsererror";p=v}if(i==="success"||i==="notmodified")j||b();else c.handleError(e,x,i,p);d();q==="timeout"&&x.abort();if(e.async)x=null}};try{var h=x.abort;x.abort=function(){x&&h.call(x);
-g("abort")}}catch(l){}e.async&&e.timeout>0&&setTimeout(function(){x&&!E&&g("timeout")},e.timeout);try{x.send(n==="POST"||n==="PUT"||n==="DELETE"?e.data:null)}catch(m){c.handleError(e,x,null,m);d()}e.async||g();return x}},handleError:function(a,b,d,f){if(a.error)a.error.call(a.context||a,b,d,f);if(a.global)(a.context?c(a.context):c.event).trigger("ajaxError",[b,a,f])},active:0,httpSuccess:function(a){try{return!a.status&&location.protocol==="file:"||a.status>=200&&a.status<300||a.status===304||a.status===
-1223||a.status===0}catch(b){}return false},httpNotModified:function(a,b){var d=a.getResponseHeader("Last-Modified"),f=a.getResponseHeader("Etag");if(d)c.lastModified[b]=d;if(f)c.etag[b]=f;return a.status===304||a.status===0},httpData:function(a,b,d){var f=a.getResponseHeader("content-type")||"",e=b==="xml"||!b&&f.indexOf("xml")>=0;a=e?a.responseXML:a.responseText;e&&a.documentElement.nodeName==="parsererror"&&c.error("parsererror");if(d&&d.dataFilter)a=d.dataFilter(a,b);if(typeof a==="string")if(b===
-"json"||!b&&f.indexOf("json")>=0)a=c.parseJSON(a);else if(b==="script"||!b&&f.indexOf("javascript")>=0)c.globalEval(a);return a},param:function(a,b){function d(i,o){if(c.isArray(o))c.each(o,function(k,n){b||/\[\]$/.test(i)?f(i,n):d(i+"["+(typeof n==="object"||c.isArray(n)?k:"")+"]",n)});else!b&&o!=null&&typeof o==="object"?c.each(o,function(k,n){d(i+"["+k+"]",n)}):f(i,o)}function f(i,o){o=c.isFunction(o)?o():o;e[e.length]=encodeURIComponent(i)+"="+encodeURIComponent(o)}var e=[];if(b===w)b=c.ajaxSettings.traditional;
-if(c.isArray(a)||a.jquery)c.each(a,function(){f(this.name,this.value)});else for(var j in a)d(j,a[j]);return e.join("&").replace(yb,"+")}});var la={},Ab=/toggle|show|hide/,Bb=/^([+-]=)?([\d+-.]+)(.*)$/,W,va=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];c.fn.extend({show:function(a,b){if(a||a===0)return this.animate(K("show",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");
-this[a].style.display=d||"";if(c.css(this[a],"display")==="none"){d=this[a].nodeName;var f;if(la[d])f=la[d];else{var e=c("<"+d+" />").appendTo("body");f=e.css("display");if(f==="none")f="block";e.remove();la[d]=f}c.data(this[a],"olddisplay",f)}}a=0;for(b=this.length;a<b;a++)this[a].style.display=c.data(this[a],"olddisplay")||"";return this}},hide:function(a,b){if(a||a===0)return this.animate(K("hide",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");!d&&d!=="none"&&c.data(this[a],
-"olddisplay",c.css(this[a],"display"))}a=0;for(b=this.length;a<b;a++)this[a].style.display="none";return this}},_toggle:c.fn.toggle,toggle:function(a,b){var d=typeof a==="boolean";if(c.isFunction(a)&&c.isFunction(b))this._toggle.apply(this,arguments);else a==null||d?this.each(function(){var f=d?a:c(this).is(":hidden");c(this)[f?"show":"hide"]()}):this.animate(K("toggle",3),a,b);return this},fadeTo:function(a,b,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,d)},
-animate:function(a,b,d,f){var e=c.speed(b,d,f);if(c.isEmptyObject(a))return this.each(e.complete);return this[e.queue===false?"each":"queue"](function(){var j=c.extend({},e),i,o=this.nodeType===1&&c(this).is(":hidden"),k=this;for(i in a){var n=i.replace(ia,ja);if(i!==n){a[n]=a[i];delete a[i];i=n}if(a[i]==="hide"&&o||a[i]==="show"&&!o)return j.complete.call(this);if((i==="height"||i==="width")&&this.style){j.display=c.css(this,"display");j.overflow=this.style.overflow}if(c.isArray(a[i])){(j.specialEasing=
-j.specialEasing||{})[i]=a[i][1];a[i]=a[i][0]}}if(j.overflow!=null)this.style.overflow="hidden";j.curAnim=c.extend({},a);c.each(a,function(r,u){var z=new c.fx(k,j,r);if(Ab.test(u))z[u==="toggle"?o?"show":"hide":u](a);else{var C=Bb.exec(u),B=z.cur(true)||0;if(C){u=parseFloat(C[2]);var E=C[3]||"px";if(E!=="px"){k.style[r]=(u||1)+E;B=(u||1)/z.cur(true)*B;k.style[r]=B+E}if(C[1])u=(C[1]==="-="?-1:1)*u+B;z.custom(B,u,E)}else z.custom(B,u,"")}});return true})},stop:function(a,b){var d=c.timers;a&&this.queue([]);
-this.each(function(){for(var f=d.length-1;f>=0;f--)if(d[f].elem===this){b&&d[f](true);d.splice(f,1)}});b||this.dequeue();return this}});c.each({slideDown:K("show",1),slideUp:K("hide",1),slideToggle:K("toggle",1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"}},function(a,b){c.fn[a]=function(d,f){return this.animate(b,d,f)}});c.extend({speed:function(a,b,d){var f=a&&typeof a==="object"?a:{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};f.duration=c.fx.off?0:typeof f.duration===
-"number"?f.duration:c.fx.speeds[f.duration]||c.fx.speeds._default;f.old=f.complete;f.complete=function(){f.queue!==false&&c(this).dequeue();c.isFunction(f.old)&&f.old.call(this)};return f},easing:{linear:function(a,b,d,f){return d+f*a},swing:function(a,b,d,f){return(-Math.cos(a*Math.PI)/2+0.5)*f+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]||
-c.fx.step._default)(this);if((this.prop==="height"||this.prop==="width")&&this.elem.style)this.elem.style.display="block"},cur:function(a){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==null))return this.elem[this.prop];return(a=parseFloat(c.css(this.elem,this.prop,a)))&&a>-10000?a:parseFloat(c.curCSS(this.elem,this.prop))||0},custom:function(a,b,d){function f(j){return e.step(j)}this.startTime=J();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start;
-this.pos=this.state=0;var e=this;f.elem=this.elem;if(f()&&c.timers.push(f)&&!W)W=setInterval(c.fx.tick,13)},show:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.show=true;this.custom(this.prop==="width"||this.prop==="height"?1:0,this.cur());c(this.elem).show()},hide:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(a){var b=J(),d=true;if(a||b>=this.options.duration+this.startTime){this.now=
-this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var f in this.options.curAnim)if(this.options.curAnim[f]!==true)d=false;if(d){if(this.options.display!=null){this.elem.style.overflow=this.options.overflow;a=c.data(this.elem,"olddisplay");this.elem.style.display=a?a:this.options.display;if(c.css(this.elem,"display")==="none")this.elem.style.display="block"}this.options.hide&&c(this.elem).hide();if(this.options.hide||this.options.show)for(var e in this.options.curAnim)c.style(this.elem,
-e,this.options.orig[e]);this.options.complete.call(this.elem)}return false}else{e=b-this.startTime;this.state=e/this.options.duration;a=this.options.easing||(c.easing.swing?"swing":"linear");this.pos=c.easing[this.options.specialEasing&&this.options.specialEasing[this.prop]||a](this.state,e,0,1,this.options.duration);this.now=this.start+(this.end-this.start)*this.pos;this.update()}return true}};c.extend(c.fx,{tick:function(){for(var a=c.timers,b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||
-c.fx.stop()},stop:function(){clearInterval(W);W=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){c.style(a.elem,"opacity",a.now)},_default:function(a){if(a.elem.style&&a.elem.style[a.prop]!=null)a.elem.style[a.prop]=(a.prop==="width"||a.prop==="height"?Math.max(0,a.now):a.now)+a.unit;else a.elem[a.prop]=a.now}}});if(c.expr&&c.expr.filters)c.expr.filters.animated=function(a){return c.grep(c.timers,function(b){return a===b.elem}).length};c.fn.offset="getBoundingClientRect"in s.documentElement?
-function(a){var b=this[0];if(a)return this.each(function(e){c.offset.setOffset(this,a,e)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);var d=b.getBoundingClientRect(),f=b.ownerDocument;b=f.body;f=f.documentElement;return{top:d.top+(self.pageYOffset||c.support.boxModel&&f.scrollTop||b.scrollTop)-(f.clientTop||b.clientTop||0),left:d.left+(self.pageXOffset||c.support.boxModel&&f.scrollLeft||b.scrollLeft)-(f.clientLeft||b.clientLeft||0)}}:function(a){var b=
-this[0];if(a)return this.each(function(r){c.offset.setOffset(this,a,r)});if(!b||!b.ownerDocument)return null;if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);c.offset.initialize();var d=b.offsetParent,f=b,e=b.ownerDocument,j,i=e.documentElement,o=e.body;f=(e=e.defaultView)?e.getComputedStyle(b,null):b.currentStyle;for(var k=b.offsetTop,n=b.offsetLeft;(b=b.parentNode)&&b!==o&&b!==i;){if(c.offset.supportsFixedPosition&&f.position==="fixed")break;j=e?e.getComputedStyle(b,null):b.currentStyle;
-k-=b.scrollTop;n-=b.scrollLeft;if(b===d){k+=b.offsetTop;n+=b.offsetLeft;if(c.offset.doesNotAddBorder&&!(c.offset.doesAddBorderForTableAndCells&&/^t(able|d|h)$/i.test(b.nodeName))){k+=parseFloat(j.borderTopWidth)||0;n+=parseFloat(j.borderLeftWidth)||0}f=d;d=b.offsetParent}if(c.offset.subtractsBorderForOverflowNotVisible&&j.overflow!=="visible"){k+=parseFloat(j.borderTopWidth)||0;n+=parseFloat(j.borderLeftWidth)||0}f=j}if(f.position==="relative"||f.position==="static"){k+=o.offsetTop;n+=o.offsetLeft}if(c.offset.supportsFixedPosition&&
-f.position==="fixed"){k+=Math.max(i.scrollTop,o.scrollTop);n+=Math.max(i.scrollLeft,o.scrollLeft)}return{top:k,left:n}};c.offset={initialize:function(){var a=s.body,b=s.createElement("div"),d,f,e,j=parseFloat(c.curCSS(a,"marginTop",true))||0;c.extend(b.style,{position:"absolute",top:0,left:0,margin:0,border:0,width:"1px",height:"1px",visibility:"hidden"});b.innerHTML="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";
-a.insertBefore(b,a.firstChild);d=b.firstChild;f=d.firstChild;e=d.nextSibling.firstChild.firstChild;this.doesNotAddBorder=f.offsetTop!==5;this.doesAddBorderForTableAndCells=e.offsetTop===5;f.style.position="fixed";f.style.top="20px";this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15;f.style.position=f.style.top="";d.style.overflow="hidden";d.style.position="relative";this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5;this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==j;a.removeChild(b);
-c.offset.initialize=c.noop},bodyOffset:function(a){var b=a.offsetTop,d=a.offsetLeft;c.offset.initialize();if(c.offset.doesNotIncludeMarginInBodyOffset){b+=parseFloat(c.curCSS(a,"marginTop",true))||0;d+=parseFloat(c.curCSS(a,"marginLeft",true))||0}return{top:b,left:d}},setOffset:function(a,b,d){if(/static/.test(c.curCSS(a,"position")))a.style.position="relative";var f=c(a),e=f.offset(),j=parseInt(c.curCSS(a,"top",true),10)||0,i=parseInt(c.curCSS(a,"left",true),10)||0;if(c.isFunction(b))b=b.call(a,
-d,e);d={top:b.top-e.top+j,left:b.left-e.left+i};"using"in b?b.using.call(a,d):f.css(d)}};c.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),d=this.offset(),f=/^body|html$/i.test(b[0].nodeName)?{top:0,left:0}:b.offset();d.top-=parseFloat(c.curCSS(a,"marginTop",true))||0;d.left-=parseFloat(c.curCSS(a,"marginLeft",true))||0;f.top+=parseFloat(c.curCSS(b[0],"borderTopWidth",true))||0;f.left+=parseFloat(c.curCSS(b[0],"borderLeftWidth",true))||0;return{top:d.top-
-f.top,left:d.left-f.left}},offsetParent:function(){return this.map(function(){for(var a=this.offsetParent||s.body;a&&!/^body|html$/i.test(a.nodeName)&&c.css(a,"position")==="static";)a=a.offsetParent;return a})}});c.each(["Left","Top"],function(a,b){var d="scroll"+b;c.fn[d]=function(f){var e=this[0],j;if(!e)return null;if(f!==w)return this.each(function(){if(j=wa(this))j.scrollTo(!a?f:c(j).scrollLeft(),a?f:c(j).scrollTop());else this[d]=f});else return(j=wa(e))?"pageXOffset"in j?j[a?"pageYOffset":
-"pageXOffset"]:c.support.boxModel&&j.document.documentElement[d]||j.document.body[d]:e[d]}});c.each(["Height","Width"],function(a,b){var d=b.toLowerCase();c.fn["inner"+b]=function(){return this[0]?c.css(this[0],d,false,"padding"):null};c.fn["outer"+b]=function(f){return this[0]?c.css(this[0],d,false,f?"margin":"border"):null};c.fn[d]=function(f){var e=this[0];if(!e)return f==null?null:this;if(c.isFunction(f))return this.each(function(j){var i=c(this);i[d](f.call(this,j,i[d]()))});return"scrollTo"in
-e&&e.document?e.document.compatMode==="CSS1Compat"&&e.document.documentElement["client"+b]||e.document.body["client"+b]:e.nodeType===9?Math.max(e.documentElement["client"+b],e.body["scroll"+b],e.documentElement["scroll"+b],e.body["offset"+b],e.documentElement["offset"+b]):f===w?c.css(e,d):this.css(d,typeof f==="string"?f:f+"px")}});A.jQuery=A.$=c})(window);
diff --git a/doc/build/_static/minus.png b/doc/build/_static/minus.png
deleted file mode 100644
index da1c5620d10c047525a467a425abe9ff5269cfc2..0000000000000000000000000000000000000000
Binary files a/doc/build/_static/minus.png and /dev/null differ
diff --git a/doc/build/_static/navigation.png b/doc/build/_static/navigation.png
deleted file mode 100644
index 1081dc1439fb984dfa7ef627afe3c7dc476fdbce..0000000000000000000000000000000000000000
Binary files a/doc/build/_static/navigation.png and /dev/null differ
diff --git a/doc/build/_static/plus.png b/doc/build/_static/plus.png
deleted file mode 100644
index b3cb37425ea68b39ffa7b2e5fb69161275a87541..0000000000000000000000000000000000000000
Binary files a/doc/build/_static/plus.png and /dev/null differ
diff --git a/doc/build/_static/pygments.css b/doc/build/_static/pygments.css
deleted file mode 100644
index a55a3248c73bb0b024dec2a94268bf44d9e150db..0000000000000000000000000000000000000000
--- a/doc/build/_static/pygments.css
+++ /dev/null
@@ -1,59 +0,0 @@
-.c { color: #408090; font-style: italic } /* Comment */
-.err { border: 1px solid #FF0000 } /* Error */
-.k { color: #007020; font-weight: bold } /* Keyword */
-.o { color: #666666 } /* Operator */
-.cm { color: #408090; font-style: italic } /* Comment.Multiline */
-.cp { color: #007020 } /* Comment.Preproc */
-.c1 { color: #408090; font-style: italic } /* Comment.Single */
-.cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
-.gd { color: #A00000 } /* Generic.Deleted */
-.ge { font-style: italic } /* Generic.Emph */
-.gr { color: #FF0000 } /* Generic.Error */
-.gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.gi { color: #00A000 } /* Generic.Inserted */
-.go { color: #303030 } /* Generic.Output */
-.gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
-.gs { font-weight: bold } /* Generic.Strong */
-.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.gt { color: #0040D0 } /* Generic.Traceback */
-.kc { color: #007020; font-weight: bold } /* Keyword.Constant */
-.kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
-.kp { color: #007020 } /* Keyword.Pseudo */
-.kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
-.kt { color: #902000 } /* Keyword.Type */
-.m { color: #208050 } /* Literal.Number */
-.s { color: #4070a0 } /* Literal.String */
-.na { color: #4070a0 } /* Name.Attribute */
-.nb { color: #007020 } /* Name.Builtin */
-.nc { color: #0e84b5; font-weight: bold } /* Name.Class */
-.no { color: #60add5 } /* Name.Constant */
-.nd { color: #555555; font-weight: bold } /* Name.Decorator */
-.ni { color: #d55537; font-weight: bold } /* Name.Entity */
-.ne { color: #007020 } /* Name.Exception */
-.nf { color: #06287e } /* Name.Function */
-.nl { color: #002070; font-weight: bold } /* Name.Label */
-.nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
-.nt { color: #062873; font-weight: bold } /* Name.Tag */
-.nv { color: #bb60d5 } /* Name.Variable */
-.ow { color: #007020; font-weight: bold } /* Operator.Word */
-.w { color: #bbbbbb } /* Text.Whitespace */
-.mf { color: #208050 } /* Literal.Number.Float */
-.mh { color: #208050 } /* Literal.Number.Hex */
-.mi { color: #208050 } /* Literal.Number.Integer */
-.mo { color: #208050 } /* Literal.Number.Oct */
-.sb { color: #4070a0 } /* Literal.String.Backtick */
-.sc { color: #4070a0 } /* Literal.String.Char */
-.sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
-.s2 { color: #4070a0 } /* Literal.String.Double */
-.se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
-.sh { color: #4070a0 } /* Literal.String.Heredoc */
-.si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
-.sx { color: #c65d09 } /* Literal.String.Other */
-.sr { color: #235388 } /* Literal.String.Regex */
-.s1 { color: #4070a0 } /* Literal.String.Single */
-.ss { color: #517918 } /* Literal.String.Symbol */
-.bp { color: #007020 } /* Name.Builtin.Pseudo */
-.vc { color: #bb60d5 } /* Name.Variable.Class */
-.vg { color: #bb60d5 } /* Name.Variable.Global */
-.vi { color: #bb60d5 } /* Name.Variable.Instance */
-.il { color: #208050 } /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/doc/build/_static/rightsidebar.css b/doc/build/_static/rightsidebar.css
deleted file mode 100644
index bc604a8931b9e38c947c0cd4d56990b05fb96bd4..0000000000000000000000000000000000000000
--- a/doc/build/_static/rightsidebar.css
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * Sphinx Doc Design -- Right Side Bar Overrides
- */
-
-
-div.sphinxsidebar {
- float: right;
-}
-
-div.bodywrapper {
- margin: 0 230px 0 0;
-}
-
-div.inlinecomments {
- right: 250px;
-}
diff --git a/doc/build/_static/searchtools.js b/doc/build/_static/searchtools.js
deleted file mode 100644
index 513a7bad30f9ba153f0e6399a3285766739fdb31..0000000000000000000000000000000000000000
--- a/doc/build/_static/searchtools.js
+++ /dev/null
@@ -1,505 +0,0 @@
-/*
- * searchtools.js
- * ~~~~~~~~~~~~~~
- *
- * Sphinx JavaScript utilties for the full-text search.
- *
- * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-/**
- * helper function to return a node containing the
- * search summary for a given text. keywords is a list
- * of stemmed words, hlwords is the list of normal, unstemmed
- * words. the first one is used to find the occurance, the
- * latter for highlighting it.
- */
-
-jQuery.makeSearchSummary = function(text, keywords, hlwords) {
- var textLower = text.toLowerCase();
- var start = 0;
- $.each(keywords, function() {
- var i = textLower.indexOf(this.toLowerCase());
- if (i > -1)
- start = i;
- });
- start = Math.max(start - 120, 0);
- var excerpt = ((start > 0) ? '...' : '') +
- $.trim(text.substr(start, 240)) +
- ((start + 240 - text.length) ? '...' : '');
- var rv = $('<div class="context"></div>').text(excerpt);
- $.each(hlwords, function() {
- rv = rv.highlightText(this, 'highlighted');
- });
- return rv;
-}
-
-/**
- * Porter Stemmer
- */
-var PorterStemmer = function() {
-
- var step2list = {
- ational: 'ate',
- tional: 'tion',
- enci: 'ence',
- anci: 'ance',
- izer: 'ize',
- bli: 'ble',
- alli: 'al',
- entli: 'ent',
- eli: 'e',
- ousli: 'ous',
- ization: 'ize',
- ation: 'ate',
- ator: 'ate',
- alism: 'al',
- iveness: 'ive',
- fulness: 'ful',
- ousness: 'ous',
- aliti: 'al',
- iviti: 'ive',
- biliti: 'ble',
- logi: 'log'
- };
-
- var step3list = {
- icate: 'ic',
- ative: '',
- alize: 'al',
- iciti: 'ic',
- ical: 'ic',
- ful: '',
- ness: ''
- };
-
- var c = "[^aeiou]"; // consonant
- var v = "[aeiouy]"; // vowel
- var C = c + "[^aeiouy]*"; // consonant sequence
- var V = v + "[aeiou]*"; // vowel sequence
-
- var mgr0 = "^(" + C + ")?" + V + C; // [C]VC... is m>0
- var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
- var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
- var s_v = "^(" + C + ")?" + v; // vowel in stem
-
- this.stemWord = function (w) {
- var stem;
- var suffix;
- var firstch;
- var origword = w;
-
- if (w.length < 3)
- return w;
-
- var re;
- var re2;
- var re3;
- var re4;
-
- firstch = w.substr(0,1);
- if (firstch == "y")
- w = firstch.toUpperCase() + w.substr(1);
-
- // Step 1a
- re = /^(.+?)(ss|i)es$/;
- re2 = /^(.+?)([^s])s$/;
-
- if (re.test(w))
- w = w.replace(re,"$1$2");
- else if (re2.test(w))
- w = w.replace(re2,"$1$2");
-
- // Step 1b
- re = /^(.+?)eed$/;
- re2 = /^(.+?)(ed|ing)$/;
- if (re.test(w)) {
- var fp = re.exec(w);
- re = new RegExp(mgr0);
- if (re.test(fp[1])) {
- re = /.$/;
- w = w.replace(re,"");
- }
- }
- else if (re2.test(w)) {
- var fp = re2.exec(w);
- stem = fp[1];
- re2 = new RegExp(s_v);
- if (re2.test(stem)) {
- w = stem;
- re2 = /(at|bl|iz)$/;
- re3 = new RegExp("([^aeiouylsz])\\1$");
- re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
- if (re2.test(w))
- w = w + "e";
- else if (re3.test(w)) {
- re = /.$/;
- w = w.replace(re,"");
- }
- else if (re4.test(w))
- w = w + "e";
- }
- }
-
- // Step 1c
- re = /^(.+?)y$/;
- if (re.test(w)) {
- var fp = re.exec(w);
- stem = fp[1];
- re = new RegExp(s_v);
- if (re.test(stem))
- w = stem + "i";
- }
-
- // Step 2
- re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
- if (re.test(w)) {
- var fp = re.exec(w);
- stem = fp[1];
- suffix = fp[2];
- re = new RegExp(mgr0);
- if (re.test(stem))
- w = stem + step2list[suffix];
- }
-
- // Step 3
- re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
- if (re.test(w)) {
- var fp = re.exec(w);
- stem = fp[1];
- suffix = fp[2];
- re = new RegExp(mgr0);
- if (re.test(stem))
- w = stem + step3list[suffix];
- }
-
- // Step 4
- re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
- re2 = /^(.+?)(s|t)(ion)$/;
- if (re.test(w)) {
- var fp = re.exec(w);
- stem = fp[1];
- re = new RegExp(mgr1);
- if (re.test(stem))
- w = stem;
- }
- else if (re2.test(w)) {
- var fp = re2.exec(w);
- stem = fp[1] + fp[2];
- re2 = new RegExp(mgr1);
- if (re2.test(stem))
- w = stem;
- }
-
- // Step 5
- re = /^(.+?)e$/;
- if (re.test(w)) {
- var fp = re.exec(w);
- stem = fp[1];
- re = new RegExp(mgr1);
- re2 = new RegExp(meq1);
- re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
- if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
- w = stem;
- }
- re = /ll$/;
- re2 = new RegExp(mgr1);
- if (re.test(w) && re2.test(w)) {
- re = /.$/;
- w = w.replace(re,"");
- }
-
- // and turn initial Y back to y
- if (firstch == "y")
- w = firstch.toLowerCase() + w.substr(1);
- return w;
- }
-}
-
-
-/**
- * Search Module
- */
-var Search = {
-
- _index : null,
- _queued_query : null,
- _pulse_status : -1,
-
- init : function() {
- var params = $.getQueryParameters();
- if (params.q) {
- var query = params.q[0];
- $('input[name="q"]')[0].value = query;
- this.performSearch(query);
- }
- },
-
- loadIndex : function(url) {
- $.ajax({type: "GET", url: url, data: null, success: null,
- dataType: "script", cache: true});
- },
-
- setIndex : function(index) {
- var q;
- this._index = index;
- if ((q = this._queued_query) !== null) {
- this._queued_query = null;
- Search.query(q);
- }
- },
-
- hasIndex : function() {
- return this._index !== null;
- },
-
- deferQuery : function(query) {
- this._queued_query = query;
- },
-
- stopPulse : function() {
- this._pulse_status = 0;
- },
-
- startPulse : function() {
- if (this._pulse_status >= 0)
- return;
- function pulse() {
- Search._pulse_status = (Search._pulse_status + 1) % 4;
- var dotString = '';
- for (var i = 0; i < Search._pulse_status; i++)
- dotString += '.';
- Search.dots.text(dotString);
- if (Search._pulse_status > -1)
- window.setTimeout(pulse, 500);
- };
- pulse();
- },
-
- /**
- * perform a search for something
- */
- performSearch : function(query) {
- // create the required interface elements
- this.out = $('#search-results');
- this.title = $('<h2>' + _('Searching') + '</h2>').appendTo(this.out);
- this.dots = $('<span></span>').appendTo(this.title);
- this.status = $('<p style="display: none"></p>').appendTo(this.out);
- this.output = $('<ul class="search"/>').appendTo(this.out);
-
- $('#search-progress').text(_('Preparing search...'));
- this.startPulse();
-
- // index already loaded, the browser was quick!
- if (this.hasIndex())
- this.query(query);
- else
- this.deferQuery(query);
- },
-
- query : function(query) {
- var stopwords = ['and', 'then', 'into', 'it', 'as', 'are', 'in',
- 'if', 'for', 'no', 'there', 'their', 'was', 'is',
- 'be', 'to', 'that', 'but', 'they', 'not', 'such',
- 'with', 'by', 'a', 'on', 'these', 'of', 'will',
- 'this', 'near', 'the', 'or', 'at'];
-
- // stem the searchterms and add them to the correct list
- var stemmer = new PorterStemmer();
- var searchterms = [];
- var excluded = [];
- var hlterms = [];
- var tmp = query.split(/\s+/);
- var object = (tmp.length == 1) ? tmp[0].toLowerCase() : null;
- for (var i = 0; i < tmp.length; i++) {
- if ($u.indexOf(stopwords, tmp[i]) != -1 || tmp[i].match(/^\d+$/) ||
- tmp[i] == "") {
- // skip this "word"
- continue;
- }
- // stem the word
- var word = stemmer.stemWord(tmp[i]).toLowerCase();
- // select the correct list
- if (word[0] == '-') {
- var toAppend = excluded;
- word = word.substr(1);
- }
- else {
- var toAppend = searchterms;
- hlterms.push(tmp[i].toLowerCase());
- }
- // only add if not already in the list
- if (!$.contains(toAppend, word))
- toAppend.push(word);
- };
- var highlightstring = '?highlight=' + $.urlencode(hlterms.join(" "));
-
- // console.debug('SEARCH: searching for:');
- // console.info('required: ', searchterms);
- // console.info('excluded: ', excluded);
-
- // prepare search
- var filenames = this._index.filenames;
- var titles = this._index.titles;
- var terms = this._index.terms;
- var objects = this._index.objects;
- var objtypes = this._index.objtypes;
- var objnames = this._index.objnames;
- var fileMap = {};
- var files = null;
- // different result priorities
- var importantResults = [];
- var objectResults = [];
- var regularResults = [];
- var unimportantResults = [];
- $('#search-progress').empty();
-
- // lookup as object
- if (object != null) {
- for (var prefix in objects) {
- for (var name in objects[prefix]) {
- var fullname = (prefix ? prefix + '.' : '') + name;
- if (fullname.toLowerCase().indexOf(object) > -1) {
- match = objects[prefix][name];
- descr = objnames[match[1]] + _(', in ') + titles[match[0]];
- // XXX the generated anchors are not generally correct
- // XXX there may be custom prefixes
- result = [filenames[match[0]], fullname, '#'+fullname, descr];
- switch (match[2]) {
- case 1: objectResults.push(result); break;
- case 0: importantResults.push(result); break;
- case 2: unimportantResults.push(result); break;
- }
- }
- }
- }
- }
-
- // sort results descending
- objectResults.sort(function(a, b) {
- return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
- });
-
- importantResults.sort(function(a, b) {
- return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
- });
-
- unimportantResults.sort(function(a, b) {
- return (a[1] > b[1]) ? -1 : ((a[1] < b[1]) ? 1 : 0);
- });
-
-
- // perform the search on the required terms
- for (var i = 0; i < searchterms.length; i++) {
- var word = searchterms[i];
- // no match but word was a required one
- if ((files = terms[word]) == null)
- break;
- if (files.length == undefined) {
- files = [files];
- }
- // create the mapping
- for (var j = 0; j < files.length; j++) {
- var file = files[j];
- if (file in fileMap)
- fileMap[file].push(word);
- else
- fileMap[file] = [word];
- }
- }
-
- // now check if the files don't contain excluded terms
- for (var file in fileMap) {
- var valid = true;
-
- // check if all requirements are matched
- if (fileMap[file].length != searchterms.length)
- continue;
-
- // ensure that none of the excluded terms is in the
- // search result.
- for (var i = 0; i < excluded.length; i++) {
- if (terms[excluded[i]] == file ||
- $.contains(terms[excluded[i]] || [], file)) {
- valid = false;
- break;
- }
- }
-
- // if we have still a valid result we can add it
- // to the result list
- if (valid)
- regularResults.push([filenames[file], titles[file], '', null]);
- }
-
- // delete unused variables in order to not waste
- // memory until list is retrieved completely
- delete filenames, titles, terms;
-
- // now sort the regular results descending by title
- regularResults.sort(function(a, b) {
- var left = a[1].toLowerCase();
- var right = b[1].toLowerCase();
- return (left > right) ? -1 : ((left < right) ? 1 : 0);
- });
-
- // combine all results
- var results = unimportantResults.concat(regularResults)
- .concat(objectResults).concat(importantResults);
-
- // print the results
- var resultCount = results.length;
- function displayNextItem() {
- // results left, load the summary and display it
- if (results.length) {
- var item = results.pop();
- var listItem = $('<li style="display:none"></li>');
- listItem.append($('<a/>').attr(
- 'href',
- item[0] + DOCUMENTATION_OPTIONS.FILE_SUFFIX +
- highlightstring + item[2]).html(item[1]));
- if (item[3]) {
- listItem.append($('<span> (' + item[3] + ')</span>'));
- Search.output.append(listItem);
- listItem.slideDown(5, function() {
- displayNextItem();
- });
- } else if (DOCUMENTATION_OPTIONS.HAS_SOURCE) {
- $.get(DOCUMENTATION_OPTIONS.URL_ROOT + '_sources/' +
- item[0] + '.txt', function(data) {
- if (data != '') {
- listItem.append($.makeSearchSummary(data, searchterms, hlterms));
- Search.output.append(listItem);
- listItem.slideDown(5, function() {
- displayNextItem();
- });
- }
- });
- } else {
- // no source available, just display title
- Search.output.append(listItem);
- listItem.slideDown(5, function() {
- displayNextItem();
- });
- }
- }
- // search finished, update title and status message
- else {
- Search.stopPulse();
- Search.title.text(_('Search Results'));
- if (!resultCount)
- Search.status.text(_('Your search did not match any documents. Please make sure that all words are spelled correctly and that you\'ve selected enough categories.'));
- else
- Search.status.text(_('Search finished, found %s page(s) matching the search query.').replace('%s', resultCount));
- Search.status.fadeIn(500);
- }
- }
- displayNextItem();
- }
-}
-
-$(document).ready(function() {
- Search.init();
-});
diff --git a/doc/build/_static/sphinxdoc.css b/doc/build/_static/sphinxdoc.css
deleted file mode 100644
index c7e6e335a29dbe36ddfc0666dc2603e637040cb0..0000000000000000000000000000000000000000
--- a/doc/build/_static/sphinxdoc.css
+++ /dev/null
@@ -1,339 +0,0 @@
-/*
- * sphinxdoc.css_t
- * ~~~~~~~~~~~~~~~
- *
- * Sphinx stylesheet -- sphinxdoc theme. Originally created by
- * Armin Ronacher for Werkzeug.
- *
- * :copyright: Copyright 2007-2010 by the Sphinx team, see AUTHORS.
- * :license: BSD, see LICENSE for details.
- *
- */
-
-@import url("basic.css");
-
-/* -- page layout ----------------------------------------------------------- */
-
-body {
- font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
- 'Verdana', sans-serif;
- font-size: 14px;
- letter-spacing: -0.01em;
- line-height: 150%;
- text-align: center;
- background-color: #BFD1D4;
- color: black;
- padding: 0;
- border: 1px solid #aaa;
-
- margin: 0px 80px 0px 80px;
- min-width: 740px;
-}
-
-div.document {
- background-color: white;
- text-align: left;
- background-image: url(contents.png);
- background-repeat: repeat-x;
-}
-
-div.bodywrapper {
- margin: 0 240px 0 0;
- border-right: 1px solid #ccc;
-}
-
-div.body {
- margin: 0;
- padding: 0.5em 20px 20px 20px;
-}
-
-div.related {
- font-size: 1em;
-}
-
-div.related ul {
- background-image: url(navigation.png);
- height: 2em;
- border-top: 1px solid #ddd;
- border-bottom: 1px solid #ddd;
-}
-
-div.related ul li {
- margin: 0;
- padding: 0;
- height: 2em;
- float: left;
-}
-
-div.related ul li.right {
- float: right;
- margin-right: 5px;
-}
-
-div.related ul li a {
- margin: 0;
- padding: 0 5px 0 5px;
- line-height: 1.75em;
- color: #EE9816;
-}
-
-div.related ul li a:hover {
- color: #3CA8E7;
-}
-
-div.sphinxsidebarwrapper {
- padding: 0;
-}
-
-div.sphinxsidebar {
- margin: 0;
- padding: 0.5em 15px 15px 0;
- width: 210px;
- float: right;
- font-size: 1em;
- text-align: left;
-}
-
-div.sphinxsidebar h3, div.sphinxsidebar h4 {
- margin: 1em 0 0.5em 0;
- font-size: 1em;
- padding: 0.1em 0 0.1em 0.5em;
- color: white;
- border: 1px solid #86989B;
- background-color: #AFC1C4;
-}
-
-div.sphinxsidebar h3 a {
- color: white;
-}
-
-div.sphinxsidebar ul {
- padding-left: 1.5em;
- margin-top: 7px;
- padding: 0;
- line-height: 130%;
-}
-
-div.sphinxsidebar ul ul {
- margin-left: 20px;
-}
-
-div.footer {
- background-color: #E3EFF1;
- color: #86989B;
- padding: 3px 8px 3px 0;
- clear: both;
- font-size: 0.8em;
- text-align: right;
-}
-
-div.footer a {
- color: #86989B;
- text-decoration: underline;
-}
-
-/* -- body styles ----------------------------------------------------------- */
-
-p {
- margin: 0.8em 0 0.5em 0;
-}
-
-a {
- color: #CA7900;
- text-decoration: none;
-}
-
-a:hover {
- color: #2491CF;
-}
-
-div.body a {
- text-decoration: underline;
-}
-
-h1 {
- margin: 0;
- padding: 0.7em 0 0.3em 0;
- font-size: 1.5em;
- color: #11557C;
-}
-
-h2 {
- margin: 1.3em 0 0.2em 0;
- font-size: 1.35em;
- padding: 0;
-}
-
-h3 {
- margin: 1em 0 -0.3em 0;
- font-size: 1.2em;
-}
-
-div.body h1 a, div.body h2 a, div.body h3 a, div.body h4 a, div.body h5 a, div.body h6 a {
- color: black!important;
-}
-
-h1 a.anchor, h2 a.anchor, h3 a.anchor, h4 a.anchor, h5 a.anchor, h6 a.anchor {
- display: none;
- margin: 0 0 0 0.3em;
- padding: 0 0.2em 0 0.2em;
- color: #aaa!important;
-}
-
-h1:hover a.anchor, h2:hover a.anchor, h3:hover a.anchor, h4:hover a.anchor,
-h5:hover a.anchor, h6:hover a.anchor {
- display: inline;
-}
-
-h1 a.anchor:hover, h2 a.anchor:hover, h3 a.anchor:hover, h4 a.anchor:hover,
-h5 a.anchor:hover, h6 a.anchor:hover {
- color: #777;
- background-color: #eee;
-}
-
-a.headerlink {
- color: #c60f0f!important;
- font-size: 1em;
- margin-left: 6px;
- padding: 0 4px 0 4px;
- text-decoration: none!important;
-}
-
-a.headerlink:hover {
- background-color: #ccc;
- color: white!important;
-}
-
-cite, code, tt {
- font-family: 'Consolas', 'Deja Vu Sans Mono',
- 'Bitstream Vera Sans Mono', monospace;
- font-size: 0.95em;
- letter-spacing: 0.01em;
-}
-
-tt {
- background-color: #f2f2f2;
- border-bottom: 1px solid #ddd;
- color: #333;
-}
-
-tt.descname, tt.descclassname, tt.xref {
- border: 0;
-}
-
-hr {
- border: 1px solid #abc;
- margin: 2em;
-}
-
-a tt {
- border: 0;
- color: #CA7900;
-}
-
-a tt:hover {
- color: #2491CF;
-}
-
-pre {
- font-family: 'Consolas', 'Deja Vu Sans Mono',
- 'Bitstream Vera Sans Mono', monospace;
- font-size: 0.95em;
- letter-spacing: 0.015em;
- line-height: 120%;
- padding: 0.5em;
- border: 1px solid #ccc;
- background-color: #f8f8f8;
-}
-
-pre a {
- color: inherit;
- text-decoration: underline;
-}
-
-td.linenos pre {
- padding: 0.5em 0;
-}
-
-div.quotebar {
- background-color: #f8f8f8;
- max-width: 250px;
- float: right;
- padding: 2px 7px;
- border: 1px solid #ccc;
-}
-
-div.topic {
- background-color: #f8f8f8;
-}
-
-table {
- border-collapse: collapse;
- margin: 0 -0.5em 0 -0.5em;
-}
-
-table td, table th {
- padding: 0.2em 0.5em 0.2em 0.5em;
-}
-
-div.admonition, div.warning {
- font-size: 0.9em;
- margin: 1em 0 1em 0;
- border: 1px solid #86989B;
- background-color: #f7f7f7;
- padding: 0;
-}
-
-div.admonition p, div.warning p {
- margin: 0.5em 1em 0.5em 1em;
- padding: 0;
-}
-
-div.admonition pre, div.warning pre {
- margin: 0.4em 1em 0.4em 1em;
-}
-
-div.admonition p.admonition-title,
-div.warning p.admonition-title {
- margin: 0;
- padding: 0.1em 0 0.1em 0.5em;
- color: white;
- border-bottom: 1px solid #86989B;
- font-weight: bold;
- background-color: #AFC1C4;
-}
-
-div.warning {
- border: 1px solid #940000;
-}
-
-div.warning p.admonition-title {
- background-color: #CF0000;
- border-bottom-color: #940000;
-}
-
-div.admonition ul, div.admonition ol,
-div.warning ul, div.warning ol {
- margin: 0.1em 0.5em 0.5em 3em;
- padding: 0;
-}
-
-div.versioninfo {
- margin: 1em 0 0 0;
- border: 1px solid #ccc;
- background-color: #DDEAF0;
- padding: 8px;
- line-height: 1.3em;
- font-size: 0.9em;
-}
-
-.viewcode-back {
- font-family: 'Lucida Grande', 'Lucida Sans Unicode', 'Geneva',
- 'Verdana', sans-serif;
-}
-
-div.viewcode-block:target {
- background-color: #f4debf;
- border-top: 1px solid #ac9;
- border-bottom: 1px solid #ac9;
-}
diff --git a/doc/build/_static/stickysidebar.css b/doc/build/_static/stickysidebar.css
deleted file mode 100644
index dfc99c77aeec9a5e6b89fec642b72f8fc1b4fd52..0000000000000000000000000000000000000000
--- a/doc/build/_static/stickysidebar.css
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Sphinx Doc Design -- Sticky sidebar Overrides
- */
-
-div.sphinxsidebar {
- top: 30px;
- left: 0px;
- position: fixed;
- margin: 0;
- float: none;
-}
-
-div.related {
- position: fixed;
-}
-
-div.documentwrapper {
- margin-top: 30px;
-}
diff --git a/doc/build/_static/traditional.css b/doc/build/_static/traditional.css
deleted file mode 100644
index 8c224c073e0f9b4795c3c2bd6474410ae1372004..0000000000000000000000000000000000000000
--- a/doc/build/_static/traditional.css
+++ /dev/null
@@ -1,700 +0,0 @@
-/**
- * Sphinx Doc Design -- traditional python.org style
- */
-
-body {
- color: #000;
- margin: 0;
- padding: 0;
-}
-
-/* :::: LAYOUT :::: */
-
-div.documentwrapper {
- float: left;
- width: 100%;
-}
-
-div.bodywrapper {
- margin: 0 230px 0 0;
-}
-
-div.body {
- background-color: white;
- padding: 0 20px 30px 20px;
-}
-
-div.sphinxsidebarwrapper {
- border: 1px solid #99ccff;
- padding: 10px;
- margin: 10px 15px 10px 0;
-}
-
-div.sphinxsidebar {
- float: right;
- margin-left: -100%;
- width: 230px;
-}
-
-div.clearer {
- clear: both;
-}
-
-div.footer {
- clear: both;
- width: 100%;
- background-color: #99ccff;
- padding: 9px 0 9px 0;
- text-align: center;
-}
-
-div.related {
- background-color: #99ccff;
- color: #333;
- width: 100%;
- height: 30px;
- line-height: 30px;
- border-bottom: 5px solid white;
-}
-
-div.related h3 {
- display: none;
-}
-
-div.related ul {
- margin: 0;
- padding: 0 0 0 10px;
- list-style: none;
-}
-
-div.related li {
- display: inline;
- font-weight: bold;
-}
-
-div.related li.right {
- float: right;
- margin-right: 5px;
-}
-
-/* ::: SIDEBAR :::: */
-div.sphinxsidebar h3 {
- margin: 0;
-}
-
-div.sphinxsidebar h4 {
- margin: 5px 0 0 0;
-}
-
-div.sphinxsidebar p.topless {
- margin: 5px 10px 10px 10px;
-}
-
-div.sphinxsidebar ul {
- margin: 10px;
- margin-left: 15px;
- padding: 0;
-}
-
-div.sphinxsidebar ul ul {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-div.sphinxsidebar form {
- margin-top: 10px;
-}
-
-
-/* :::: SEARCH :::: */
-ul.search {
- margin: 10px 0 0 20px;
- padding: 0;
-}
-
-ul.search li {
- padding: 5px 0 5px 20px;
- background-image: url(file.png);
- background-repeat: no-repeat;
- background-position: 0 7px;
-}
-
-ul.search li a {
- font-weight: bold;
-}
-
-ul.search li div.context {
- color: #888;
- margin: 2px 0 0 30px;
- text-align: left;
-}
-
-ul.keywordmatches li.goodmatch a {
- font-weight: bold;
-}
-
-/* :::: COMMON FORM STYLES :::: */
-
-div.actions {
- border-top: 1px solid #aaa;
- background-color: #ddd;
- margin: 10px 0 0 -20px;
- padding: 5px 0 5px 20px;
-}
-
-form dl {
- color: #333;
-}
-
-form dt {
- clear: both;
- float: left;
- min-width: 110px;
- margin-right: 10px;
- padding-top: 2px;
-}
-
-input#homepage {
- display: none;
-}
-
-div.error {
- margin: 5px 20px 0 0;
- padding: 5px;
- border: 1px solid #d00;
- /*border: 2px solid #05171e;
- background-color: #092835;
- color: white;*/
- font-weight: bold;
-}
-
-/* :::: INLINE COMMENTS :::: */
-
-div.inlinecommentswrapper {
- float: right;
- max-width: 40%;
-}
-
-div.commentmarker {
- float: right;
- background-image: url(style/comment.png);
- background-repeat: no-repeat;
- width: 25px;
- height: 25px;
- text-align: center;
- padding-top: 3px;
-}
-
-div.nocommentmarker {
- float: right;
- background-image: url(style/nocomment.png);
- background-repeat: no-repeat;
- width: 25px;
- height: 25px;
-}
-
-div.inlinecomments {
- margin-left: 10px;
- margin-bottom: 5px;
- background-color: #eee;
- border: 1px solid #ccc;
- padding: 5px;
-}
-
-div.inlinecomment {
- border-top: 1px solid #ccc;
- padding-top: 5px;
- margin-top: 5px;
-}
-
-.inlinecomments p {
- margin: 5px 0 5px 0;
-}
-
-.inlinecomments .head {
- font-weight: bold;
-}
-
-.inlinecomments .meta {
- font-style: italic;
-}
-
-
-/* :::: COMMENTS :::: */
-
-div#comments h3 {
- border-top: 1px solid #aaa;
- padding: 5px 20px 5px 20px;
- margin: 20px -20px 20px -20px;
- background-color: #ddd;
-}
-
-/*
-div#comments {
- background-color: #ccc;
- margin: 40px -20px -30px -20px;
- padding: 0 0 1px 0;
-}
-
-div#comments h4 {
- margin: 30px 0 20px 0;
- background-color: #aaa;
- border-bottom: 1px solid #09232e;
- color: #333;
-}
-
-div#comments form {
- display: block;
- margin: 0 0 0 20px;
-}
-
-div#comments textarea {
- width: 98%;
- height: 160px;
-}
-
-div#comments div.help {
- margin: 20px 20px 10px 0;
- background-color: #ccc;
- color: #333;
-}
-
-div#comments div.help p {
- margin: 0;
- padding: 0 0 10px 0;
-}
-
-div#comments input, div#comments textarea {
- font-family: 'Bitstream Vera Sans', 'Arial', sans-serif;
- font-size: 13px;
- color: black;
- background-color: #aaa;
- border: 1px solid #092835;
-}
-
-div#comments input[type="reset"],
-div#comments input[type="submit"] {
- cursor: pointer;
- font-weight: bold;
- padding: 2px;
- margin: 5px 5px 5px 0;
- background-color: #666;
- color: white;
-}
-
-div#comments div.comment {
- margin: 10px 10px 10px 20px;
- padding: 10px;
- border: 1px solid #0f3646;
- background-color: #aaa;
- color: #333;
-}
-
-div#comments div.comment p {
- margin: 5px 0 5px 0;
-}
-
-div#comments div.comment p.meta {
- font-style: italic;
- color: #444;
- text-align: right;
- margin: -5px 0 -5px 0;
-}
-
-div#comments div.comment h4 {
- margin: -10px -10px 5px -10px;
- padding: 3px;
- font-size: 15px;
- background-color: #888;
- color: white;
- border: 0;
-}
-
-div#comments div.comment pre,
-div#comments div.comment tt {
- background-color: #ddd;
- color: #111;
- border: none;
-}
-
-div#comments div.comment a {
- color: #fff;
- text-decoration: underline;
-}
-
-div#comments div.comment blockquote {
- margin: 10px;
- padding: 10px;
- border-left: 1px solid #0f3646;
- /*border: 1px solid #0f3646;
- background-color: #071c25;*/
-}
-
-div#comments em.important {
- color: #d00;
- font-weight: bold;
- font-style: normal;
-}*/
-
-/* :::: SUGGEST CHANGES :::: */
-div#suggest-changes-box input, div#suggest-changes-box textarea {
- border: 1px solid #ccc;
- background-color: white;
- color: black;
-}
-
-div#suggest-changes-box textarea {
- width: 99%;
- height: 400px;
-}
-
-
-/* :::: PREVIEW :::: */
-div.preview {
- background-image: url(style/preview.png);
- padding: 0 20px 20px 20px;
- margin-bottom: 30px;
-}
-
-
-/* :::: INDEX PAGE :::: */
-
-table.contentstable {
- width: 90%;
-}
-
-table.contentstable p.biglink {
- line-height: 150%;
-}
-
-a.biglink {
- font-size: 1.5em;
-}
-
-span.linkdescr {
- font-style: italic;
- padding-top: 5px;
-}
-
-/* :::: GENINDEX STYLES :::: */
-
-table.indextable td {
- text-align: left;
- vertical-align: top;
-}
-
-table.indextable dl, table.indextable dd {
- margin-top: 0;
- margin-bottom: 0;
-}
-
-table.indextable tr.pcap {
- height: 10px;
-}
-
-table.indextable tr.cap {
- margin-top: 10px;
- background-color: #f2f2f2;
-}
-
-img.toggler {
- margin-right: 3px;
- margin-top: 3px;
- cursor: pointer;
-}
-
-/* :::: GLOBAL STYLES :::: */
-
-p.subhead {
- font-weight: bold;
- margin-top: 20px;
-}
-
-a:link:active { color: #ff0000; }
-a:link:hover { background-color: #bbeeff; }
-a:visited:hover { background-color: #bbeeff; }
-a:visited { color: #551a8b; }
-a:link { color: #0000bb; }
-
-div.body h1,
-div.body h2,
-div.body h3,
-div.body h4,
-div.body h5,
-div.body h6 {
- font-family: avantgarde, sans-serif;
- font-weight: bold;
-}
-
-div.body h1 { font-size: 180%; }
-div.body h2 { font-size: 150%; }
-div.body h3 { font-size: 120%; }
-div.body h4 { font-size: 120%; }
-
-a.headerlink,
-a.headerlink,
-a.headerlink,
-a.headerlink,
-a.headerlink,
-a.headerlink {
- color: #c60f0f;
- font-size: 0.8em;
- padding: 0 4px 0 4px;
- text-decoration: none;
- visibility: hidden;
-}
-
-*:hover > a.headerlink,
-*:hover > a.headerlink,
-*:hover > a.headerlink,
-*:hover > a.headerlink,
-*:hover > a.headerlink,
-*:hover > a.headerlink {
- visibility: visible;
-}
-
-a.headerlink:hover,
-a.headerlink:hover,
-a.headerlink:hover,
-a.headerlink:hover,
-a.headerlink:hover,
-a.headerlink:hover {
- background-color: #c60f0f;
- color: white;
-}
-
-div.body p, div.body dd, div.body li {
- text-align: justify;
-}
-
-div.body td {
- text-align: left;
-}
-
-ul.fakelist {
- list-style: none;
- margin: 10px 0 10px 20px;
- padding: 0;
-}
-
-/* "Footnotes" heading */
-p.rubric {
- margin-top: 30px;
- font-weight: bold;
-}
-
-/* "Topics" */
-
-div.topic {
- background-color: #eee;
- border: 1px solid #ccc;
- padding: 0 7px 0 7px;
- margin: 10px 0 10px 0;
-}
-
-p.topic-title {
- font-size: 1.1em;
- font-weight: bold;
- margin-top: 10px;
-}
-
-/* Admonitions */
-
-div.admonition {
- margin-top: 10px;
- margin-bottom: 10px;
- padding: 7px;
-}
-
-div.admonition dt {
- font-weight: bold;
-}
-
-div.admonition dd {
- margin-bottom: 10px;
-}
-
-div.admonition dl {
- margin-bottom: 0;
-}
-
-div.admonition p {
- display: inline;
-}
-
-div.seealso {
- background-color: #ffc;
- border: 1px solid #ff6;
-}
-
-div.warning {
- background-color: #ffe4e4;
- border: 1px solid #f66;
-}
-
-div.note {
- background-color: #eee;
- border: 1px solid #ccc;
-}
-
-p.admonition-title {
- margin: 0px 10px 5px 0px;
- font-weight: bold;
- display: inline;
-}
-
-p.admonition-title:after {
- content: ":";
-}
-
-div.body p.centered {
- text-align: center;
- margin-top: 25px;
-}
-
-table.docutils {
- border: 0;
-}
-
-table.docutils td, table.docutils th {
- padding: 0 8px 2px 0;
- border-top: 0;
- border-left: 0;
- border-right: 0;
- border-bottom: 1px solid #aaa;
-}
-
-table.field-list td, table.field-list th {
- border: 0 !important;
-}
-
-table.footnote td, table.footnote th {
- border: 0 !important;
-}
-
-dl {
- margin-bottom: 15px;
- clear: both;
-}
-
-dd p {
- margin-top: 0px;
-}
-
-dd ul, dd table {
- margin-bottom: 10px;
-}
-
-dd {
- margin-top: 3px;
- margin-bottom: 10px;
- margin-left: 30px;
-}
-
-dl.glossary dt {
- font-weight: bold;
- font-size: 1.1em;
-}
-
-.refcount {
- color: #060;
-}
-
-th {
- text-align: left;
- padding-right: 5px;
-}
-
-pre {
- font-family: monospace;
- padding: 5px;
- color: #00008b;
- border-left: none;
- border-right: none;
-}
-
-tt {
- font-family: monospace;
- background-color: #ecf0f3;
- padding: 0 1px 0 1px;
-}
-
-tt.descname {
- background-color: transparent;
- font-weight: bold;
- font-size: 1.2em;
-}
-
-tt.descclassname {
- background-color: transparent;
-}
-
-tt.xref, a tt {
- background-color: transparent;
- font-weight: bold;
-}
-
-.footnote:target { background-color: #ffa }
-
-h1 tt, h2 tt, h3 tt, h4 tt, h5 tt, h6 tt {
- background-color: transparent;
-}
-
-.optional {
- font-size: 1.3em;
-}
-
-.versionmodified {
- font-style: italic;
-}
-
-form.comment {
- margin: 0;
- padding: 10px 30px 10px 30px;
- background-color: #eee;
-}
-
-form.comment h3 {
- background-color: #326591;
- color: white;
- margin: -10px -30px 10px -30px;
- padding: 5px;
- font-size: 1.4em;
-}
-
-form.comment input,
-form.comment textarea {
- border: 1px solid #ccc;
- padding: 2px;
- font-family: sans-serif;
- font-size: 13px;
-}
-
-form.comment input[type="text"] {
- width: 240px;
-}
-
-form.comment textarea {
- width: 100%;
- height: 200px;
- margin-bottom: 10px;
-}
-
-/* :::: PRINT :::: */
-@media print {
- div.documentwrapper {
- width: 100%;
- }
-
- div.body {
- margin: 0;
- }
-
- div.sphinxsidebar,
- div.related,
- div.footer,
- div#comments div.new-comment-box,
- #top-link {
- display: none;
- }
-}
diff --git a/doc/build/_static/underscore.js b/doc/build/_static/underscore.js
deleted file mode 100644
index 9146e086001d7bcba14c8f73d99a87e353458824..0000000000000000000000000000000000000000
--- a/doc/build/_static/underscore.js
+++ /dev/null
@@ -1,16 +0,0 @@
-(function(){var j=this,n=j._,i=function(a){this._wrapped=a},m=typeof StopIteration!=="undefined"?StopIteration:"__break__",b=j._=function(a){return new i(a)};if(typeof exports!=="undefined")exports._=b;var k=Array.prototype.slice,o=Array.prototype.unshift,p=Object.prototype.toString,q=Object.prototype.hasOwnProperty,r=Object.prototype.propertyIsEnumerable;b.VERSION="0.5.5";b.each=function(a,c,d){try{if(a.forEach)a.forEach(c,d);else if(b.isArray(a)||b.isArguments(a))for(var e=0,f=a.length;e<f;e++)c.call(d,
-a[e],e,a);else{var g=b.keys(a);f=g.length;for(e=0;e<f;e++)c.call(d,a[g[e]],g[e],a)}}catch(h){if(h!=m)throw h;}return a};b.map=function(a,c,d){if(a&&b.isFunction(a.map))return a.map(c,d);var e=[];b.each(a,function(f,g,h){e.push(c.call(d,f,g,h))});return e};b.reduce=function(a,c,d,e){if(a&&b.isFunction(a.reduce))return a.reduce(b.bind(d,e),c);b.each(a,function(f,g,h){c=d.call(e,c,f,g,h)});return c};b.reduceRight=function(a,c,d,e){if(a&&b.isFunction(a.reduceRight))return a.reduceRight(b.bind(d,e),c);
-var f=b.clone(b.toArray(a)).reverse();b.each(f,function(g,h){c=d.call(e,c,g,h,a)});return c};b.detect=function(a,c,d){var e;b.each(a,function(f,g,h){if(c.call(d,f,g,h)){e=f;b.breakLoop()}});return e};b.select=function(a,c,d){if(a&&b.isFunction(a.filter))return a.filter(c,d);var e=[];b.each(a,function(f,g,h){c.call(d,f,g,h)&&e.push(f)});return e};b.reject=function(a,c,d){var e=[];b.each(a,function(f,g,h){!c.call(d,f,g,h)&&e.push(f)});return e};b.all=function(a,c,d){c=c||b.identity;if(a&&b.isFunction(a.every))return a.every(c,
-d);var e=true;b.each(a,function(f,g,h){(e=e&&c.call(d,f,g,h))||b.breakLoop()});return e};b.any=function(a,c,d){c=c||b.identity;if(a&&b.isFunction(a.some))return a.some(c,d);var e=false;b.each(a,function(f,g,h){if(e=c.call(d,f,g,h))b.breakLoop()});return e};b.include=function(a,c){if(b.isArray(a))return b.indexOf(a,c)!=-1;var d=false;b.each(a,function(e){if(d=e===c)b.breakLoop()});return d};b.invoke=function(a,c){var d=b.rest(arguments,2);return b.map(a,function(e){return(c?e[c]:e).apply(e,d)})};b.pluck=
-function(a,c){return b.map(a,function(d){return d[c]})};b.max=function(a,c,d){if(!c&&b.isArray(a))return Math.max.apply(Math,a);var e={computed:-Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;g>=e.computed&&(e={value:f,computed:g})});return e.value};b.min=function(a,c,d){if(!c&&b.isArray(a))return Math.min.apply(Math,a);var e={computed:Infinity};b.each(a,function(f,g,h){g=c?c.call(d,f,g,h):f;g<e.computed&&(e={value:f,computed:g})});return e.value};b.sortBy=function(a,c,d){return b.pluck(b.map(a,
-function(e,f,g){return{value:e,criteria:c.call(d,e,f,g)}}).sort(function(e,f){e=e.criteria;f=f.criteria;return e<f?-1:e>f?1:0}),"value")};b.sortedIndex=function(a,c,d){d=d||b.identity;for(var e=0,f=a.length;e<f;){var g=e+f>>1;d(a[g])<d(c)?(e=g+1):(f=g)}return e};b.toArray=function(a){if(!a)return[];if(a.toArray)return a.toArray();if(b.isArray(a))return a;if(b.isArguments(a))return k.call(a);return b.values(a)};b.size=function(a){return b.toArray(a).length};b.first=function(a,c,d){return c&&!d?k.call(a,
-0,c):a[0]};b.rest=function(a,c,d){return k.call(a,b.isUndefined(c)||d?1:c)};b.last=function(a){return a[a.length-1]};b.compact=function(a){return b.select(a,function(c){return!!c})};b.flatten=function(a){return b.reduce(a,[],function(c,d){if(b.isArray(d))return c.concat(b.flatten(d));c.push(d);return c})};b.without=function(a){var c=b.rest(arguments);return b.select(a,function(d){return!b.include(c,d)})};b.uniq=function(a,c){return b.reduce(a,[],function(d,e,f){if(0==f||(c===true?b.last(d)!=e:!b.include(d,
-e)))d.push(e);return d})};b.intersect=function(a){var c=b.rest(arguments);return b.select(b.uniq(a),function(d){return b.all(c,function(e){return b.indexOf(e,d)>=0})})};b.zip=function(){for(var a=b.toArray(arguments),c=b.max(b.pluck(a,"length")),d=new Array(c),e=0;e<c;e++)d[e]=b.pluck(a,String(e));return d};b.indexOf=function(a,c){if(a.indexOf)return a.indexOf(c);for(var d=0,e=a.length;d<e;d++)if(a[d]===c)return d;return-1};b.lastIndexOf=function(a,c){if(a.lastIndexOf)return a.lastIndexOf(c);for(var d=
-a.length;d--;)if(a[d]===c)return d;return-1};b.range=function(a,c,d){var e=b.toArray(arguments),f=e.length<=1;a=f?0:e[0];c=f?e[0]:e[1];d=e[2]||1;e=Math.ceil((c-a)/d);if(e<=0)return[];e=new Array(e);f=a;for(var g=0;1;f+=d){if((d>0?f-c:c-f)>=0)return e;e[g++]=f}};b.bind=function(a,c){var d=b.rest(arguments,2);return function(){return a.apply(c||j,d.concat(b.toArray(arguments)))}};b.bindAll=function(a){var c=b.rest(arguments);if(c.length==0)c=b.functions(a);b.each(c,function(d){a[d]=b.bind(a[d],a)});
-return a};b.delay=function(a,c){var d=b.rest(arguments,2);return setTimeout(function(){return a.apply(a,d)},c)};b.defer=function(a){return b.delay.apply(b,[a,1].concat(b.rest(arguments)))};b.wrap=function(a,c){return function(){var d=[a].concat(b.toArray(arguments));return c.apply(c,d)}};b.compose=function(){var a=b.toArray(arguments);return function(){for(var c=b.toArray(arguments),d=a.length-1;d>=0;d--)c=[a[d].apply(this,c)];return c[0]}};b.keys=function(a){if(b.isArray(a))return b.range(0,a.length);
-var c=[];for(var d in a)q.call(a,d)&&c.push(d);return c};b.values=function(a){return b.map(a,b.identity)};b.functions=function(a){return b.select(b.keys(a),function(c){return b.isFunction(a[c])}).sort()};b.extend=function(a,c){for(var d in c)a[d]=c[d];return a};b.clone=function(a){if(b.isArray(a))return a.slice(0);return b.extend({},a)};b.tap=function(a,c){c(a);return a};b.isEqual=function(a,c){if(a===c)return true;var d=typeof a;if(d!=typeof c)return false;if(a==c)return true;if(!a&&c||a&&!c)return false;
-if(a.isEqual)return a.isEqual(c);if(b.isDate(a)&&b.isDate(c))return a.getTime()===c.getTime();if(b.isNaN(a)&&b.isNaN(c))return true;if(b.isRegExp(a)&&b.isRegExp(c))return a.source===c.source&&a.global===c.global&&a.ignoreCase===c.ignoreCase&&a.multiline===c.multiline;if(d!=="object")return false;if(a.length&&a.length!==c.length)return false;d=b.keys(a);var e=b.keys(c);if(d.length!=e.length)return false;for(var f in a)if(!b.isEqual(a[f],c[f]))return false;return true};b.isEmpty=function(a){return b.keys(a).length==
-0};b.isElement=function(a){return!!(a&&a.nodeType==1)};b.isArray=function(a){return!!(a&&a.concat&&a.unshift)};b.isArguments=function(a){return a&&b.isNumber(a.length)&&!b.isArray(a)&&!r.call(a,"length")};b.isFunction=function(a){return!!(a&&a.constructor&&a.call&&a.apply)};b.isString=function(a){return!!(a===""||a&&a.charCodeAt&&a.substr)};b.isNumber=function(a){return p.call(a)==="[object Number]"};b.isDate=function(a){return!!(a&&a.getTimezoneOffset&&a.setUTCFullYear)};b.isRegExp=function(a){return!!(a&&
-a.test&&a.exec&&(a.ignoreCase||a.ignoreCase===false))};b.isNaN=function(a){return b.isNumber(a)&&isNaN(a)};b.isNull=function(a){return a===null};b.isUndefined=function(a){return typeof a=="undefined"};b.noConflict=function(){j._=n;return this};b.identity=function(a){return a};b.breakLoop=function(){throw m;};var s=0;b.uniqueId=function(a){var c=s++;return a?a+c:c};b.template=function(a,c){a=new Function("obj","var p=[],print=function(){p.push.apply(p,arguments);};with(obj){p.push('"+a.replace(/[\r\t\n]/g,
-" ").replace(/'(?=[^%]*%>)/g,"\t").split("'").join("\\'").split("\t").join("'").replace(/<%=(.+?)%>/g,"',$1,'").split("<%").join("');").split("%>").join("p.push('")+"');}return p.join('');");return c?a(c):a};b.forEach=b.each;b.foldl=b.inject=b.reduce;b.foldr=b.reduceRight;b.filter=b.select;b.every=b.all;b.some=b.any;b.head=b.first;b.tail=b.rest;b.methods=b.functions;var l=function(a,c){return c?b(a).chain():a};b.each(b.functions(b),function(a){var c=b[a];i.prototype[a]=function(){var d=b.toArray(arguments);
-o.call(d,this._wrapped);return l(c.apply(b,d),this._chain)}});b.each(["pop","push","reverse","shift","sort","splice","unshift"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){c.apply(this._wrapped,arguments);return l(this._wrapped,this._chain)}});b.each(["concat","join","slice"],function(a){var c=Array.prototype[a];i.prototype[a]=function(){return l(c.apply(this._wrapped,arguments),this._chain)}});i.prototype.chain=function(){this._chain=true;return this};i.prototype.value=function(){return this._wrapped}})();
diff --git a/doc/build/base/base.html b/doc/build/base/base.html
deleted file mode 100644
index 72196eb83c5f04a5738fec96f106dd14162706fb..0000000000000000000000000000000000000000
--- a/doc/build/base/base.html
+++ /dev/null
@@ -1,156 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>ost.settings - Locate Files and Retrieve Preferences — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="next" title="io - Input and Output of Sequences, Structures and Maps" href="../io/io.html" />
- <link rel="prev" title="seq – Sequences and Alignments" href="../seq/base/seq.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../io/io.html" title="io - Input and Output of Sequences, Structures and Maps"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../seq/base/seq.html" title="seq – Sequences and Alignments"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h4>Previous topic</h4>
- <p class="topless"><a href="../seq/base/seq.html"
- title="previous chapter"><tt class="docutils literal"><span class="pre">seq</span></tt> – Sequences and Alignments</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../io/io.html"
- title="next chapter"><tt class="docutils literal"><span class="pre">io</span></tt> - Input and Output of Sequences, Structures and Maps</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/base/base.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.settings">
-<span id="ost-settings-locate-files-and-retrieve-preferences"></span><h1><a class="reference internal" href="#module-ost.settings" title="Helper Functions to Locate Files and Retrieve Preferences"><tt class="xref py py-mod docutils literal"><span class="pre">ost.settings</span></tt></a> - Locate Files and Retrieve Preferences<a class="headerlink" href="#module-ost.settings" title="Permalink to this headline">¶</a></h1>
-<dl class="exception">
-<dt id="ost.settings.FileNotFound">
-<em class="property">exception </em><tt class="descclassname">ost.settings.</tt><tt class="descname">FileNotFound</tt><big>(</big><em>name</em>, <em>reason</em><big>)</big><a class="headerlink" href="#ost.settings.FileNotFound" title="Permalink to this definition">¶</a></dt>
-<dd><p>Raised when <a class="reference internal" href="#ost.settings.Locate" title="ost.settings.Locate"><tt class="xref py py-func docutils literal"><span class="pre">Locate()</span></tt></a> is unable to locate a file. The exception contains
-detailed information on what was tried to locate the file, i.e. search paths,
-environment variables and also provides useful hints on how to let Locate know
-where to find the file.</p>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.settings.GetValue">
-<tt class="descclassname">ost.settings.</tt><tt class="descname">GetValue</tt><big>(</big><em>val_key</em>, <em>val_default=None</em>, <em>prefix='OST'</em><big>)</big><a class="headerlink" href="#ost.settings.GetValue" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the value of the variable val_key if defined, otherwise returns the
-default value provided by the user (if provided). Search order:</p>
-<blockquote>
-<ul class="simple">
-<li>environment variable called $prefix_$val_key</li>
-<li>variable called val_key in .ostrc file</li>
-</ul>
-</blockquote>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.settings.Locate">
-<tt class="descclassname">ost.settings.</tt><tt class="descname">Locate</tt><big>(</big><em>file_name</em>, <em>explicit_file_name=None</em>, <em>search_paths=</em><span class="optional">[</span><span class="optional">]</span>, <em>env_name=None</em>, <em>search_system_paths=True</em><big>)</big><a class="headerlink" href="#ost.settings.Locate" title="Permalink to this definition">¶</a></dt>
-<dd><p>Helper function to locate files. To get the full name of an executable, let’s
-say qmake, use</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">abs_qmake_path</span><span class="o">=</span><span class="n">Locate</span><span class="p">(</span><span class="s">'qmake'</span><span class="p">,</span> <span class="n">env_name</span><span class="o">=</span><span class="s">'QMAKE_EXECUTABLE'</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>First the function checks if an environment variable with the name
-QMAKE_EXECUTABLE is set. If so, the value of this variable is returned. Next,
-each directory listed in search_paths is searched. If the executable could
-still not be found and search_system_paths is set to True, the binary search
-paths are searched.</p>
-<p>If the file could not be located, a <a class="reference internal" href="#ost.settings.FileNotFound" title="ost.settings.FileNotFound"><tt class="xref py py-exc docutils literal"><span class="pre">FileNotFound</span></tt></a>
-exception will be raised containing a detail description why Locate failed. The
-error message is formatted in such a way that it can directly be presented to
-the user.</p>
-</dd></dl>
-
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../io/io.html" title="io - Input and Output of Sequences, Structures and Maps"
- >next</a> |</li>
- <li class="right" >
- <a href="../seq/base/seq.html" title="seq – Sequences and Alignments"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/base/generic.html b/doc/build/base/generic.html
deleted file mode 100644
index 7239129038c2fcaa8b12a0ac0185fc4c310a5b12..0000000000000000000000000000000000000000
--- a/doc/build/base/generic.html
+++ /dev/null
@@ -1,296 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Storing Custom Data — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="next" title="img Images and Density Maps" href="../img/base/img.html" />
- <link rel="prev" title="Installing OpenStructure" href="../install.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../img/base/img.html" title="img Images and Density Maps"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../install.html" title="Installing OpenStructure"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Storing Custom Data</a><ul>
-<li><a class="reference internal" href="#introduction">Introduction</a></li>
-<li><a class="reference internal" href="#storing-and-accessing-data">Storing and Accessing Data</a></li>
-<li><a class="reference internal" href="#use-of-generic-properties-in-queries">Use of Generic Properties in Queries</a></li>
-<li><a class="reference internal" href="#api-documentation">API documentation</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="../install.html"
- title="previous chapter">Installing OpenStructure</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../img/base/img.html"
- title="next chapter"><tt class="docutils literal"><span class="pre">img</span></tt> Images and Density Maps</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/base/generic.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="storing-custom-data">
-<h1>Storing Custom Data<a class="headerlink" href="#storing-custom-data" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="introduction">
-<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
-<p>It is often very convenient to store any arbitrary data inside an Entity. A few examples are:</p>
-<blockquote>
-<ul class="simple">
-<li>calculated properties of atoms</li>
-<li>sequence conservation of a residue</li>
-<li>interaction energy of a substructure with its surrounding</li>
-<li>fit of a fragment inside an electron density map</li>
-</ul>
-</blockquote>
-<p>In OpenStructure this is supported by the use of generic properties. Most
-building blocks are derived from <a class="reference internal" href="#GenericPropertyContainer" title="GenericPropertyContainer"><tt class="xref py py-class docutils literal"><span class="pre">GenericPropertyContainer</span></tt></a>, meaning that
-arbitrary key-value pairs can be stored in them. In essence, the following
-classes support generic properties:</p>
-<blockquote>
-<ul class="simple">
-<li><tt class="xref py py-class docutils literal"><span class="pre">EntityHandle</span></tt> and <tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt></li>
-<li><tt class="xref py py-class docutils literal"><span class="pre">ChainHandle</span></tt> and <tt class="xref py py-class docutils literal"><span class="pre">ChainView</span></tt></li>
-<li><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandle</span></tt> and <tt class="xref py py-class docutils literal"><span class="pre">ResidueView</span></tt></li>
-<li><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt> and <tt class="xref py py-class docutils literal"><span class="pre">AtomView</span></tt></li>
-<li><tt class="xref py py-class docutils literal"><span class="pre">BondHandle</span></tt></li>
-<li><tt class="xref py py-class docutils literal"><span class="pre">SequenceHandle</span></tt> and <tt class="xref py py-class docutils literal"><span class="pre">AlignmentHandle</span></tt></li>
-</ul>
-</blockquote>
-<p>The view variants will reflect the generic properties of the handle variants.</p>
-<p>A generic property key is always a string, and a value can be one of string, float, int or bool. For each of these data types, methods to retrieve and store values are available both in Python and C++.</p>
-</div>
-<div class="section" id="storing-and-accessing-data">
-<h2>Storing and Accessing Data<a class="headerlink" href="#storing-and-accessing-data" title="Permalink to this headline">¶</a></h2>
-<p>All OpenStructure building blocks that are <tt class="xref py py-class docutils literal"><span class="pre">GenericPropContainers</span></tt>, have
-four different methods to store generic data, depending on the data type (i.e.
-string, float, int or bool).</p>
-<p>To store a float value with the key ‘myfloatprop’ in all atoms of an entity:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">import</span> <span class="nn">math</span>
-<span class="k">for</span> <span class="n">atom</span> <span class="ow">in</span> <span class="n">entity</span><span class="o">.</span><span class="n">GetAtomList</span><span class="p">():</span>
- <span class="n">val</span><span class="o">=</span><span class="mf">5</span><span class="o">*</span><span class="n">math</span><span class="o">.</span><span class="n">sin</span><span class="p">(</span><span class="mf">0.4</span><span class="o">*</span><span class="n">atom</span><span class="o">.</span><span class="n">GetPos</span><span class="p">()</span><span class="o">.</span><span class="n">GetX</span><span class="p">())</span>
- <span class="n">atom</span><span class="o">.</span><span class="n">SetFloatProp</span><span class="p">(</span><span class="s">"myfloatprop"</span><span class="p">,</span> <span class="n">val</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>If a GenericProp at a given level (i.e. atom, bond, residue, chain or entity)
-already exists, it will be overwritten. To check if it exists, use:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">exists</span><span class="o">=</span><span class="n">atom</span><span class="o">.</span><span class="n">HasProp</span><span class="p">(</span><span class="s">"myfloatprop"</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">exists</span>
-</pre></div>
-</div>
-<p>To access the value of a generic property, we first check if the property exists
-and then access it, using the method suitable for the data type of the property.
-For the previously set property “myfloatprop” of the data type real, at the atom
-level:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">atom</span> <span class="ow">in</span> <span class="n">entity</span><span class="o">.</span><span class="n">GetAtomList</span><span class="p">():</span>
- <span class="k">if</span> <span class="n">atom</span><span class="o">.</span><span class="n">HasProp</span><span class="p">(</span><span class="s">"myfloatprop"</span><span class="p">):</span>
- <span class="k">print</span> <span class="n">atom</span><span class="o">.</span><span class="n">GetFloatProp</span><span class="p">(</span><span class="s">"myfloatprop"</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>When trying to access a property that has not been set, or one that has been
-set, but at a different level, an error is thrown. The same is true when trying
-to access a property of a different data type, e.g.:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># all of the following lines will throw errors</span>
-<span class="c"># error because the property does not exist</span>
-<span class="k">print</span> <span class="n">atom</span><span class="o">.</span><span class="n">GetFloatProp</span><span class="p">(</span><span class="s">"unknownprop"</span><span class="p">)</span>
-
-<span class="c"># error because the property was set at another level</span>
-<span class="k">print</span> <span class="n">entity</span><span class="o">.</span><span class="n">GetFloatProp</span><span class="p">(</span><span class="s">"myfloatprop"</span><span class="p">)</span>
-
-<span class="c"># error because the data type of the property is different</span>
-<span class="k">print</span> <span class="n">atom</span><span class="o">.</span><span class="n">GetStringProp</span><span class="p">(</span><span class="s">"myfloatprop"</span><span class="p">)</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="use-of-generic-properties-in-queries">
-<h2>Use of Generic Properties in Queries<a class="headerlink" href="#use-of-generic-properties-in-queries" title="Permalink to this headline">¶</a></h2>
-<p>The <a class="reference internal" href="../mol/base/query.html"><em>Queries</em></a> can also be used for numeric generic properties (i.e. bool,
-int, float), but the syntax is slightly different. To access any generic
-properties, it needs to be specified that they are generic and at which level
-they are defined. Therefore, all generic properties start with a ‘g’, followed
-by an ‘a’, ‘r’ or ‘c’ for atom, residue or chain level respectively. For more
-details see <a class="reference internal" href="../mol/base/query.html"><em>Queries</em></a>.</p>
-</div>
-<div class="section" id="api-documentation">
-<h2>API documentation<a class="headerlink" href="#api-documentation" title="Permalink to this headline">¶</a></h2>
-<dl class="class">
-<dt id="GenericPropertyContainer">
-<em class="property">class </em><tt class="descname">GenericPropertyContainer</tt><a class="headerlink" href="#GenericPropertyContainer" title="Permalink to this definition">¶</a></dt>
-<dd><dl class="method">
-<dt id="GenericPropertyContainer.HasProp">
-<tt class="descname">HasProp</tt><big>(</big><em>key</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.HasProp" title="Permalink to this definition">¶</a></dt>
-<dd><p>checks existence of property. Returns true, if the the class contains a
-property with the given name, false if not.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.GetPropAsString">
-<tt class="descname">GetPropAsString</tt><big>(</big><em>key</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.GetPropAsString" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the string representation of a property, or the empty String if
-the property addressed by key does not exist. Note that this is not the
-same as trying to get a generic float/int/bool property as a string type;
-the latter will result in a boost:get exception. Use this method to obtain
-a representation suitable for output.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.GetStringProp">
-<tt class="descname">GetStringProp</tt><big>(</big><em>key</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.GetStringProp" title="Permalink to this definition">¶</a></dt>
-<dt>
-<tt class="descname">GetStringProp</tt><big>(</big><em>key</em>, <em>default_value</em><big>)</big></dt>
-<dd><p>Get string property. The first signature raises a GenericPropError error if
-the property does not exist, the second returns the default value.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.GetFloatProp">
-<tt class="descname">GetFloatProp</tt><big>(</big><em>key</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.GetFloatProp" title="Permalink to this definition">¶</a></dt>
-<dt>
-<tt class="descname">GetFloatProp</tt><big>(</big><em>key</em>, <em>default_value</em><big>)</big></dt>
-<dd><p>Get float property. The first signature raises a GenericPropError error if
-the property does not exist, the second returns the default value.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.GetIntProp">
-<tt class="descname">GetIntProp</tt><big>(</big><em>key</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.GetIntProp" title="Permalink to this definition">¶</a></dt>
-<dt>
-<tt class="descname">GetIntProp</tt><big>(</big><em>key</em>, <em>default_value</em><big>)</big></dt>
-<dd><p>Get int property. The first signature raises a GenericPropError error if
-the property does not exist, the second returns the default value.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.GetBoolProp">
-<tt class="descname">GetBoolProp</tt><big>(</big><em>key</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.GetBoolProp" title="Permalink to this definition">¶</a></dt>
-<dt>
-<tt class="descname">GetBoolProp</tt><big>(</big><em>key</em>, <em>default_value</em><big>)</big></dt>
-<dd><p>Get bool property. The first signature raises a GenericPropError error if
-the property does not exist, the second returns the default value.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.ClearProps">
-<tt class="descname">ClearProps</tt><big>(</big><big>)</big><a class="headerlink" href="#GenericPropertyContainer.ClearProps" title="Permalink to this definition">¶</a></dt>
-<dd><p>Remove all generic properties</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.SetStringProp">
-<tt class="descname">SetStringProp</tt><big>(</big><em>key</em>, <em>value</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.SetStringProp" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set string property, overriding an existing property with the same name</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.SetFloatProp">
-<tt class="descname">SetFloatProp</tt><big>(</big><em>key</em>, <em>value</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.SetFloatProp" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set float property, overriding an existing property with the same name</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.SetIntProp">
-<tt class="descname">SetIntProp</tt><big>(</big><em>key</em>, <em>value</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.SetIntProp" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set int property, overriding an existing property with the same name</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="GenericPropertyContainer.SetBoolProp">
-<tt class="descname">SetBoolProp</tt><big>(</big><em>key</em>, <em>value</em><big>)</big><a class="headerlink" href="#GenericPropertyContainer.SetBoolProp" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set bool property, overriding a property with the same name</p>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../img/base/img.html" title="img Images and Density Maps"
- >next</a> |</li>
- <li class="right" >
- <a href="../install.html" title="Installing OpenStructure"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/conop/conop.html b/doc/build/conop/conop.html
deleted file mode 100644
index cecd4359e92fb848066bbbfc8931587141e1eec4..0000000000000000000000000000000000000000
--- a/doc/build/conop/conop.html
+++ /dev/null
@@ -1,493 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>conop – Connectivity and Topology of Molecules — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="next" title="mol – Molecular structures and surfaces" href="../mol/base/mol.html" />
- <link rel="prev" title="Geometric Objects" href="../geom/composite.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../mol/base/mol.html" title="mol – Molecular structures and surfaces"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../geom/composite.html" title="Geometric Objects"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#"><tt class="docutils literal"><span class="pre">conop</span></tt> – Connectivity and Topology of Molecules</a><ul>
-<li><a class="reference internal" href="#motivation">Motivation</a></li>
-<li><a class="reference internal" href="#the-builder-interface">The Builder interface</a></li>
-<li><a class="reference internal" href="#connecting-atoms">Connecting atoms</a></li>
-<li><a class="reference internal" href="#convert-mm-cif-dictionary">Convert MM CIF dictionary</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="../geom/composite.html"
- title="previous chapter">Geometric Objects</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../mol/base/mol.html"
- title="next chapter"><tt class="docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/conop/conop.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.conop">
-<span id="conop-connectivity-and-topology-of-molecules"></span><h1><a class="reference internal" href="#module-ost.conop" title="The conop modules implement different strategies to derive connectivity information of molecules."><tt class="xref py py-mod docutils literal"><span class="pre">conop</span></tt></a> – Connectivity and Topology of Molecules<a class="headerlink" href="#module-ost.conop" title="Permalink to this headline">¶</a></h1>
-<p>The main task of the conop module is to connect atoms with bonds. While the
-bond class is also part of the base module, the conop module deals with setting
-up the correct bonds between atoms.</p>
-<div class="section" id="motivation">
-<h2>Motivation<a class="headerlink" href="#motivation" title="Permalink to this headline">¶</a></h2>
-<p>Traditionally the connectivity between atoms has not been reliably described in
-a PDB file. Different programs adopted various ways of finding out if two atoms
-are connected. One way chosen is to rely on proper naming of the atoms. For
-example, the backbone atoms of the standard amino acids are named as N, CA, C
-and O and if atoms with these name appear in the same residue they are shown
-connected. Another way is to apply additional heuristics to find out if a
-peptide bond between two consecutive residues is formed. Breaks in the backbone
-are indicated, e.g., by introducing a discontinuity in the numbering of the residue.</p>
-<p>Loader heuristics are great if you are the one that implemented them but are
-problematic if you are just the user of a software that has them. As time goes
-on, these heuristics become buried in thousands of lines of code and they are
-often hard yet impossible to trace back.</p>
-<p>Different clients of the framework have different requirements. A visualisation
-software wants to read in a PDB files as is without making any changes. A
-script in an automated pipeline, however, does want to either strictly reject
-files that are incomplete or fill-in missing structural features. All these
-aspects are implemented in the conop module, separated from the loading of the
-PDB file, giving clients a fine grained control over the loading process.</p>
-</div>
-<div class="section" id="the-builder-interface">
-<h2>The Builder interface<a class="headerlink" href="#the-builder-interface" title="Permalink to this headline">¶</a></h2>
-<p>The conop module defines a <a class="reference internal" href="#ost.conop.Builder" title="ost.conop.Builder"><tt class="xref py py-class docutils literal"><span class="pre">Builder</span></tt></a> interface, to run connectivity
-algorithms, that is to connect the atoms with bonds and perform basic clean up
-of errorneous structures. The clients of the conop module can specify how the
-Builder should treat unknown amino acids, missing atoms and chemically
-infeasible bonds.</p>
-<p>The exact behaviour for a builder is implementation-specific. So far, two
-classes implement the Builder interface: A heuristic and a rule-based builder. The builders mainly differ in the source of their connectivity information. The
-HeuristicBuilder uses a hard-coded heuristic connectivity table for the 20
-standard amino acids as well as nucleotides.For other compounds such as ligands
-the HeuristicBuilder runs a distance-based connectivity algorithm that connects
-two atoms if they are closer than a certain threshold. The RuleBasedBuilder
-uses a connectivity library containing all molecular components present in the
-PDB files on PDB.org. The library can easily be extended with custom
-connectivity information, if required. By default the heuristic builder is used,
-however the builder may be switched by setting the !RuleBasedBuilder as the
-default. To do so, one has first to create a new instance of a RuleBasedBuilder
-and register it in the builder registry of the conop module. In Python, this can
-be achieved with</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">from</span> <span class="nn">ost</span> <span class="k">import</span> <span class="n">conop</span>
-<span class="n">compound_lib</span><span class="o">=</span><span class="n">conop</span><span class="o">.</span><span class="n">CompoundLib</span><span class="o">.</span><span class="n">Load</span><span class="p">(</span><span class="s">'...'</span><span class="p">)</span>
-<span class="n">rbb</span><span class="o">=</span><span class="n">conop</span><span class="o">.</span><span class="n">RuleBasedBuilder</span><span class="p">(</span><span class="n">compound_lib</span><span class="p">)</span>
-<span class="n">conop</span><span class="o">.</span><span class="n">Conopology</span><span class="o">.</span><span class="n">Instance</span><span class="p">()</span><span class="o">.</span><span class="n">RegisterBuilder</span><span class="p">(</span><span class="n">rbb</span><span class="p">,</span><span class="s">'rbb'</span><span class="p">)</span>
-<span class="n">conop</span><span class="o">.</span><span class="n">Conopology</span><span class="o">.</span><span class="n">Instance</span><span class="p">()</span><span class="o">.</span><span class="n">SetDefaultBuilder</span><span class="p">(</span><span class="s">'rbb'</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>All subsequent calls to <tt class="xref py py-func docutils literal"><span class="pre">io.LoadEntity()</span></tt> will make use of the
-RuleBasedBuilder instead of the heuristic builder. See
-<a class="reference internal" href="#mmcif-convert"><em>here</em></a> for more information on how to create the necessary
-files to use the rule-based builder.</p>
-<dl class="class">
-<dt id="ost.conop.Builder">
-<em class="property">class </em><tt class="descclassname">ost.conop.</tt><tt class="descname">Builder</tt><a class="headerlink" href="#ost.conop.Builder" title="Permalink to this definition">¶</a></dt>
-<dd><dl class="method">
-<dt id="ost.conop.Builder.CompleteAtoms">
-<tt class="descname">CompleteAtoms</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.CompleteAtoms" title="Permalink to this definition">¶</a></dt>
-<dd><p>add any missing atoms to the residue based on its key, with coordinates set
-to zero.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.CheckResidueCompleteness">
-<tt class="descname">CheckResidueCompleteness</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.CheckResidueCompleteness" title="Permalink to this definition">¶</a></dt>
-<dd><p>verify that the given residue has all atoms it is supposed to have based on
-its key.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.IsResidueComplete">
-<tt class="descname">IsResidueComplete</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.IsResidueComplete" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check whether the residue has all atoms it is supposed to have. Hydrogen
-atoms are not required for a residue to be complete.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.IdentifyResidue">
-<tt class="descname">IdentifyResidue</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.IdentifyResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>attempt to identify the residue based on its atoms, and return a suggestion
-for the proper residue key.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.ConnectAtomsOfResidue">
-<tt class="descname">ConnectAtomsOfResidue</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.ConnectAtomsOfResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>Connects atoms of residue based on residue and atom name. This method does
-not establish inter-residue bonds. To connect atoms that belong to
-different residues, use <a class="reference internal" href="#ost.conop.Builder.ConnectResidueToPrev" title="ost.conop.Builder.ConnectResidueToPrev"><tt class="xref py py-meth docutils literal"><span class="pre">ConnectResidueToPrev()</span></tt></a>, or
-<tt class="xref py py-meth docutils literal"><span class="pre">ConnectResidueToNext()</span></tt>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.ConnectResidueToPrev">
-<tt class="descname">ConnectResidueToPrev</tt><big>(</big><em>residue</em>, <em>prev</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.ConnectResidueToPrev" title="Permalink to this definition">¶</a></dt>
-<dd><p>Connect atoms of residue to previous. The order of the parameters is
-important. In case of a polypeptide chain, the residues are thought to be
-ordered from N- to C- terminus.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-<li><strong>prev</strong> – valid or invalid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.DoesPeptideBondExist">
-<tt class="descname">DoesPeptideBondExist</tt><big>(</big><em>n</em>, <em>c</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.DoesPeptideBondExist" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check if peptide bond should be formed between the <cite>n</cite> and <cite>c</cite> atom. This
-method is called by ConnectResidueWithNext() after making sure that
-both residues participating in the peptide bond are peptide linking
-components.</p>
-<p>By default, <a class="reference internal" href="#ost.conop.Builder.IsBondFeasible" title="ost.conop.Builder.IsBondFeasible"><tt class="xref py py-meth docutils literal"><span class="pre">IsBondFeasible()</span></tt></a> is used to check whether the two atoms
-form a peptide bond.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>n</strong> – backbone nitrogen atom (IUPAC name <cite>N</cite>). Must be valid.</li>
-<li><strong>c</strong> – backbone C-atom (IUPAC name <cite>C</cite>). Must be valid.</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.IsBondFeasible">
-<tt class="descname">IsBondFeasible</tt><big>(</big><em>atom_a</em>, <em>atom_b</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.IsBondFeasible" title="Permalink to this definition">¶</a></dt>
-<dd><p>Overloadable hook to check if bond between to atoms is feasible. The
-default implementation uses a distance-based check to check if the
-two atoms should be connected. The atoms are connected if they are in
-the range of 0.8 to 1.2 times their van-der-WAALS radius.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>atom_a</strong> – a valid atom</li>
-<li><strong>atom_a</strong> – a valid atom</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.GuessAtomElement">
-<tt class="descname">GuessAtomElement</tt><big>(</big><em>atom_name</em>, <em>hetatm</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.GuessAtomElement" title="Permalink to this definition">¶</a></dt>
-<dd><p>guess element of atom based on name and hetatm flag</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>atom_name</strong> – IUPAC atom name, e.g. <cite>CA</cite>, <cite>CB</cite> or <cite>N</cite>.</li>
-<li><strong>hetatm</strong> – Whether the atom is a hetatm or not</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.Builder.AssignBackboneTorsionsToResidue">
-<tt class="descname">AssignBackboneTorsionsToResidue</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.Builder.AssignBackboneTorsionsToResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>For <tt class="xref py py-meth docutils literal"><span class="pre">peptide-linking</span> <span class="pre">residues</span></tt>,
-residues, assigns phi, psi and omega torsions to amino acid.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.conop.RuleBasedBuilder">
-<em class="property">class </em><tt class="descclassname">ost.conop.</tt><tt class="descname">RuleBasedBuilder</tt><a class="headerlink" href="#ost.conop.RuleBasedBuilder" title="Permalink to this definition">¶</a></dt>
-<dd><p>The <a class="reference internal" href="#ost.conop.RuleBasedBuilder" title="ost.conop.RuleBasedBuilder"><tt class="xref py py-class docutils literal"><span class="pre">RuleBasedBuilder</span></tt></a> implements the <a class="reference internal" href="#ost.conop.Builder" title="ost.conop.Builder"><tt class="xref py py-class docutils literal"><span class="pre">Builder</span></tt></a> interface.
-Refer to its documentation for a basic description of the methods.</p>
-<dl class="method">
-<dt id="ost.conop.RuleBasedBuilder.CheckResidueCompleteness">
-<tt class="descname">CheckResidueCompleteness</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.RuleBasedBuilder.CheckResidueCompleteness" title="Permalink to this definition">¶</a></dt>
-<dd><p>By using the description of the chemical compound, the completeness of
-the residue is verified. The method distinguishes between required atoms
-and atoms that are optional, like <cite>OXT</cite> that is only present, if not
-peptide bond is formed. Whenever an unknown atom is encountered,
-<a class="reference internal" href="#ost.conop.RuleBasedBuilder.OnUnknownAtom" title="ost.conop.RuleBasedBuilder.OnUnknownAtom"><tt class="xref py py-meth docutils literal"><span class="pre">OnUnknownAtom()</span></tt></a> is invoked. Subclasses of the
-<a class="reference internal" href="#ost.conop.RuleBasedBuilder" title="ost.conop.RuleBasedBuilder"><tt class="xref py py-class docutils literal"><span class="pre">RuleBasedBuilder</span></tt></a> may implement some additional logic to deal with
-unknown atom. Likewise, whenever a required atom is missing,
-<a class="reference internal" href="#ost.conop.RuleBasedBuilder.OnMissingAtom" title="ost.conop.RuleBasedBuilder.OnMissingAtom"><tt class="xref py py-meth docutils literal"><span class="pre">OnMissingAtom()</span></tt></a> is invoked. Hydrogen atoms are not considered as
-required by default.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.RuleBasedBuilder.IdentifyResidue">
-<tt class="descname">IdentifyResidue</tt><big>(</big><em>residue</em><big>)</big><a class="headerlink" href="#ost.conop.RuleBasedBuilder.IdentifyResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>Looks-up the residue in the database of chemical compounds and returns
-the name of the residue or “UNK” if the residue has not been found in the
-library.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>residue</strong> – must be a valid residue</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.RuleBasedBuilder.OnUnknownAtom">
-<tt class="descname">OnUnknownAtom</tt><big>(</big><em>atom</em><big>)</big><a class="headerlink" href="#ost.conop.RuleBasedBuilder.OnUnknownAtom" title="Permalink to this definition">¶</a></dt>
-<dd><p>Invoked whenever an unkknown atom has been encountered during a residue
-completeness check.</p>
-<p>The default implementation guesses the atom properties based on the name
-and returns false, meaning that it should be treated as an unknown atom.</p>
-<p>Custom implementations of this method may delete the atom, or modify it.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>atom</strong> – the unknown atom</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.conop.RuleBasedBuilder.OnMissingAtom">
-<tt class="descname">OnMissingAtom</tt><big>(</big><em>atom</em><big>)</big><a class="headerlink" href="#ost.conop.RuleBasedBuilder.OnMissingAtom" title="Permalink to this definition">¶</a></dt>
-<dd><p>Invoked whenever an atom is missing. It is up to the overloaded method
-to deal with the missing atom, either by ignoring it or by inserting a
-dummy atom.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>atom</strong> – The missing atom’s name</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="connecting-atoms">
-<h2>Connecting atoms<a class="headerlink" href="#connecting-atoms" title="Permalink to this headline">¶</a></h2>
-<p>The high level interface is exposed by the Conopoloy singleton instance:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">import</span> <span class="nn">conop</span>
-
-<span class="n">cc</span><span class="o">=</span><span class="n">conop</span><span class="o">.</span><span class="n">Conopology</span><span class="o">.</span><span class="n">Instance</span><span class="p">()</span>
-
-<span class="n">ent</span><span class="o">=</span><span class="n">BuildRawModel</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
-<span class="n">cc</span><span class="o">.</span><span class="n">ConnectAll</span><span class="p">(</span><span class="n">cc</span><span class="o">.</span><span class="n">GetBuilder</span><span class="p">(),</span> <span class="n">ent</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>For fine grained control, the builder interface may be used directly.</p>
-</div>
-<div class="section" id="convert-mm-cif-dictionary">
-<span id="mmcif-convert"></span><h2>Convert MM CIF dictionary<a class="headerlink" href="#convert-mm-cif-dictionary" title="Permalink to this headline">¶</a></h2>
-<p>The CompoundLib may be created from a MM CIF dictionary. The latest dictionary
-can be found on the <a class="reference external" href="http://www.wwpdb.org/ccd.html">wwPDB site</a>.</p>
-<p>After downloading the file in MM CIF use the <strong class="program">chemdict_tool</strong> to convert
-the MM CIF dictionary into our internal format.</p>
-<div class="highlight-bash"><div class="highlight"><pre>chemdict_tool create <components.cif> <compounds.chemlib>
-</pre></div>
-</div>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../mol/base/mol.html" title="mol – Molecular structures and surfaces"
- >next</a> |</li>
- <li class="right" >
- <a href="../geom/composite.html" title="Geometric Objects"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/external.html b/doc/build/external.html
deleted file mode 100644
index bf745b55dd2f96e4efff40ae179996e89ac2ed92..0000000000000000000000000000000000000000
--- a/doc/build/external.html
+++ /dev/null
@@ -1,213 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Using External Programs within OpenStructure — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
- <link rel="prev" title="Creating a New Module" href="newmodule.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="newmodule.html" title="Creating a New Module"
- accesskey="P">previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Using External Programs within OpenStructure</a><ul>
-<li><a class="reference internal" href="#introduction">Introduction</a></li>
-<li><a class="reference internal" href="#locating-the-executable">Locating the Executable</a></li>
-<li><a class="reference internal" href="#prepare-all-files">Prepare All Files</a></li>
-<li><a class="reference internal" href="#execute-the-external-program">Execute the External Program</a></li>
-<li><a class="reference internal" href="#read-generated-output">Read Generated Output</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="newmodule.html"
- title="previous chapter">Creating a New Module</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="_sources/external.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="using-external-programs-within-openstructure">
-<h1>Using External Programs within OpenStructure<a class="headerlink" href="#using-external-programs-within-openstructure" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="introduction">
-<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
-<p>It is often very useful to use external programs to do a specific task. In principle, this can be done by writing out files from OpenStructure and manually running an external program, however, for convenience, this can also be done directly from within OpenStructure using Python commands.</p>
-<p>This tutorial will give you some hints how to do this for a new external program. The process basically consists of four steps:</p>
-<blockquote>
-<ul class="simple">
-<li>locate the executable of the external program</li>
-<li>prepare all necessary files</li>
-<li>execute the external program from python</li>
-<li>read in generated output</li>
-</ul>
-</blockquote>
-</div>
-<div class="section" id="locating-the-executable">
-<h2>Locating the Executable<a class="headerlink" href="#locating-the-executable" title="Permalink to this headline">¶</a></h2>
-<p>There is a helper function available to locate files, and especially executables: <a class="reference internal" href="base/base.html#ost.settings.Locate" title="ost.settings.Locate"><tt class="xref py py-func docutils literal"><span class="pre">Locate()</span></tt></a>. Using this, you can obtain the full path of an executable.</p>
-<p>As an example, we would like to obtain the full path of the msms executable (a program to calculate molecular surfaces):</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">from</span> <span class="nn">ost</span> <span class="k">import</span> <span class="n">settings</span>
-<span class="n">exe_path</span><span class="o">=</span><span class="n">settings</span><span class="o">.</span><span class="n">Locate</span><span class="p">(</span><span class="s">'msms'</span><span class="p">,</span> <span class="n">search_paths</span><span class="o">=</span><span class="p">[</span><span class="s">'/opt/app'</span><span class="p">,</span><span class="s">'/home/app'</span><span class="p">],</span>
- <span class="n">env_name</span><span class="o">=</span><span class="s">'MSMS'</span><span class="p">,</span> <span class="n">search_system_paths</span><span class="o">=</span><span class="bp">True</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">exe_path</span>
-</pre></div>
-</div>
-<p>The <a class="reference internal" href="base/base.html#ost.settings.Locate" title="ost.settings.Locate"><tt class="xref py py-func docutils literal"><span class="pre">Locate()</span></tt></a> command looks for the program with the name
-<cite>msms</cite>. If env_name is set, it first looks if an environment variable with the
-name <cite>MSMS</cite> is set. If not, all paths in search_paths are searched. If the
-executable could still not be found and search_system_paths is set to True, the
-binary search paths are searched. If the executable could not be found, a
-<tt class="xref py py-exc docutils literal"><span class="pre">FileNotFound</span></tt> exception is raised with a detailed description where
-Locate was searching for the executable.</p>
-</div>
-<div class="section" id="prepare-all-files">
-<h2>Prepare All Files<a class="headerlink" href="#prepare-all-files" title="Permalink to this headline">¶</a></h2>
-<p>The preparation of the necessary files is very dependent on the external program. Often it is useful to generate a temporary directory or file. For this, the python module tempfile is very handy.</p>
-<p>An example how to generate a temporary directory, open a file in this directory and write the position and radius of all atoms into this file is shown here:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">import</span> <span class="nn">tempfile</span>
-<span class="k">import</span> <span class="nn">os</span>
-
-<span class="c"># generate a temporary directory</span>
-<span class="n">tmp_dir_name</span><span class="o">=</span><span class="n">tempfile</span><span class="o">.</span><span class="n">mkdtemp</span><span class="p">()</span>
-<span class="k">print</span> <span class="s">'temporary directory:'</span><span class="p">,</span><span class="n">tmp_dir_name</span>
-
-<span class="c"># generate and open a file in the temp directory</span>
-<span class="n">tmp_file_name</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">tmp_dir_name</span><span class="p">,</span><span class="s">"entity"</span><span class="p">)</span>
-<span class="n">tmp_file_handle</span><span class="o">=</span><span class="nb">open</span><span class="p">(</span><span class="n">tmp_file_name</span><span class="p">,</span> <span class="s">'w'</span><span class="p">)</span>
-<span class="k">print</span> <span class="s">'temporary file:'</span><span class="p">,</span><span class="n">tmp_file_handle</span>
-
-<span class="c"># write position and radius of all atoms to file</span>
-<span class="k">for</span> <span class="n">a</span> <span class="ow">in</span> <span class="n">entity</span><span class="o">.</span><span class="n">GetAtomList</span><span class="p">():</span>
- <span class="n">position</span><span class="o">=</span><span class="n">a</span><span class="o">.</span><span class="n">GetPos</span><span class="p">()</span>
- <span class="n">tmp_file_handle</span><span class="o">.</span><span class="n">write</span><span class="p">(</span><span class="s">'</span><span class="si">%8.3f</span><span class="s"> </span><span class="si">%8.3f</span><span class="s"> </span><span class="si">%8.3f</span><span class="s"> </span><span class="si">%4.2f</span><span class="se">\n</span><span class="s">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">position</span><span class="p">[</span><span class="mf">0</span><span class="p">],</span>
- <span class="n">position</span><span class="p">[</span><span class="mf">1</span><span class="p">],</span> <span class="n">position</span><span class="p">[</span><span class="mf">2</span><span class="p">],</span> <span class="n">a</span><span class="o">.</span><span class="n">GetProp</span><span class="p">()</span><span class="o">.</span><span class="n">radius</span><span class="p">))</span>
-
-<span class="c"># close the file</span>
-<span class="n">tmp_file_handle</span><span class="o">.</span><span class="n">close</span><span class="p">()</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="execute-the-external-program">
-<h2>Execute the External Program<a class="headerlink" href="#execute-the-external-program" title="Permalink to this headline">¶</a></h2>
-<p>The external program can be executed from python using the python module subprocess.</p>
-<p>To run the external program msms from the above example, with the temporary file generated before, we can use the following:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">import</span> <span class="nn">subprocess</span>
-
-<span class="c"># set the command to execute</span>
-<span class="n">command</span><span class="o">=</span><span class="s">"</span><span class="si">%s</span><span class="s"> -if </span><span class="si">%s</span><span class="s"> -of </span><span class="si">%s</span><span class="s">"</span> <span class="o">%</span> <span class="p">(</span><span class="n">exe_path</span><span class="p">,</span>
- <span class="n">tmp_file_name</span><span class="p">,</span> <span class="n">tmp_file_name</span><span class="p">)</span>
-<span class="k">print</span> <span class="s">'command:'</span><span class="p">,</span><span class="n">command</span>
-
-<span class="c"># run the executable with the command</span>
-<span class="n">proc</span> <span class="o">=</span> <span class="n">subprocess</span><span class="o">.</span><span class="n">Popen</span><span class="p">(</span><span class="n">command</span><span class="p">,</span> <span class="n">shell</span><span class="o">=</span><span class="bp">True</span><span class="p">,</span> <span class="n">stdout</span><span class="o">=</span><span class="n">subprocess</span><span class="o">.</span><span class="n">PIPE</span><span class="p">)</span>
-<span class="n">stdout_value</span><span class="p">,</span> <span class="n">stderr_value</span> <span class="o">=</span> <span class="n">proc</span><span class="o">.</span><span class="n">communicate</span><span class="p">()</span>
-
-<span class="c">#check for successful completion of msms</span>
-<span class="k">if</span> <span class="n">proc</span><span class="o">.</span><span class="n">returncode</span><span class="o">!=</span><span class="mf">0</span><span class="p">:</span>
- <span class="k">print</span> <span class="s">"WARNING: msms error</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">stdout_value</span>
- <span class="k">raise</span> <span class="n">subprocess</span><span class="o">.</span><span class="n">CalledProcessError</span><span class="p">(</span><span class="n">proc</span><span class="o">.</span><span class="n">returncode</span><span class="p">,</span> <span class="n">command</span><span class="p">)</span>
-
-<span class="c"># print everything written to the command line (stdout)</span>
-<span class="k">print</span> <span class="n">stdout_value</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="read-generated-output">
-<h2>Read Generated Output<a class="headerlink" href="#read-generated-output" title="Permalink to this headline">¶</a></h2>
-<p>The last step includes reading of generated files (like in the case of msms) and/or processing of the generated command line output.</p>
-<p>Here we first print the command line output and then load the generated msms surface and print the number of vertex points:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># print everything written to the command line (stdout)</span>
-<span class="k">print</span> <span class="n">stdout_value</span>
-
-<span class="c"># read msms surface from file</span>
-<span class="n">surface</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadSurface</span><span class="p">(</span><span class="n">tmp_file_name</span><span class="p">,</span> <span class="s">"msms"</span><span class="p">)</span>
-<span class="k">print</span> <span class="s">'number of vertices:'</span><span class="p">,</span><span class="nb">len</span><span class="p">(</span><span class="n">surface</span><span class="o">.</span><span class="n">GetVertexIDList</span><span class="p">())</span>
-</pre></div>
-</div>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="newmodule.html" title="Creating a New Module"
- >previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/genindex.html b/doc/build/genindex.html
deleted file mode 100644
index 506f7add290e5558ed2f5444e90562c789b62d1a..0000000000000000000000000000000000000000
--- a/doc/build/genindex.html
+++ /dev/null
@@ -1,588 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Index — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="#" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
-
-
-
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
-
- <h1 id="index">Index</h1>
-
- <div class="genindex-jumpbox">
- <a href="#_"><strong>_</strong></a> | <a href="#A"><strong>A</strong></a> | <a href="#B"><strong>B</strong></a> | <a href="#C"><strong>C</strong></a> | <a href="#D"><strong>D</strong></a> | <a href="#E"><strong>E</strong></a> | <a href="#F"><strong>F</strong></a> | <a href="#G"><strong>G</strong></a> | <a href="#H"><strong>H</strong></a> | <a href="#I"><strong>I</strong></a> | <a href="#L"><strong>L</strong></a> | <a href="#M"><strong>M</strong></a> | <a href="#N"><strong>N</strong></a> | <a href="#O"><strong>O</strong></a> | <a href="#P"><strong>P</strong></a> | <a href="#Q"><strong>Q</strong></a> | <a href="#R"><strong>R</strong></a> | <a href="#S"><strong>S</strong></a> | <a href="#T"><strong>T</strong></a> | <a href="#U"><strong>U</strong></a> | <a href="#V"><strong>V</strong></a> | <a href="#W"><strong>W</strong></a> | <a href="#X"><strong>X</strong></a> | <a href="#Y"><strong>Y</strong></a> | <a href="#Z"><strong>Z</strong></a>
- </div>
-<h2 id="_">_</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.__len__">__len__() (ost.seq.SequenceHandle method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.__str__">__str__() (ost.seq.SequenceHandle method)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="A">A</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.AlignedCuboid">AlignedCuboid (class in ost.geom)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentFromSequenceList">AlignmentFromSequenceList() (in module ost.seq)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle">AlignmentHandle (class in ost.seq)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Angle">Angle() (in module ost.geom)</a></dt>
- <dt><a href="mol/base/editors.html#ost.mol.EditorBase.AppendResidue">AppendResidue() (ost.mol.EditorBase method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.Apply">Apply() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/editors.html#ost.mol.XCSEditor.ApplyTransform">ApplyTransform() (ost.mol.XCSEditor method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.AreIntersecting">AreIntersecting() (in module ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.AreParallel">AreParallel() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.AssignBackboneTorsionsToResidue">AssignBackboneTorsionsToResidue() (ost.conop.Builder method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.At">At() (ost.geom.Ellipse2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Line2.At">(ost.geom.Line2 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line3.At">(ost.geom.Line3 method)</a></dt>
- </dl></dd>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.AtAngle">AtAngle() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.AtomHandle">AtomHandle (class in ost.mol)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.attached_view">attached_view (ost.seq.SequenceHandle attribute)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.AttachView">AttachView() (ost.seq.AlignmentHandle method)</a></dt>
- <dd><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.AttachView">(ost.seq.SequenceHandle method)</a></dt>
- </dl></dd>
- <dt><a href="geom/composite.html#ost.geom.Cuboid.axis_a">axis_a (ost.geom.Cuboid attribute)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Cuboid.axis_b">axis_b (ost.geom.Cuboid attribute)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Cuboid.axis_c">axis_c (ost.geom.Cuboid attribute)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.AxisRotation">AxisRotation() (in module ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="B">B</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="conop/conop.html#ost.conop.Builder">Builder (class in ost.conop)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="C">C</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Cuboid.center">center (ost.geom.Cuboid attribute)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.ChainHandle">ChainHandle (class in ost.mol)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.CheckResidueCompleteness">CheckResidueCompleteness() (ost.conop.Builder method)</a></dt>
- <dd><dl>
- <dt><a href="conop/conop.html#ost.conop.RuleBasedBuilder.CheckResidueCompleteness">(ost.conop.RuleBasedBuilder method)</a></dt>
- </dl></dd>
- <dt><a href="geom/composite.html#ost.geom.Circle2">Circle2 (class in ost.geom)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.ClearProps">ClearProps() (GenericPropertyContainer method)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.CompDivide">CompDivide() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.CompleteAtoms">CompleteAtoms() (ost.conop.Builder method)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.CompMultiply">CompMultiply() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.ConnectAtomsOfResidue">ConnectAtomsOfResidue() (ost.conop.Builder method)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.ConnectResidueToPrev">ConnectResidueToPrev() (ost.conop.Builder method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.Copy">Copy() (ost.mol.EntityHandle method)</a></dt>
- <dd><dl>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.Copy">(ost.seq.AlignmentHandle method)</a></dt>
- </dl></dd>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="seq/base/seq.html#ost.seq.CreateAlignment">CreateAlignment() (in module ost.seq)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.CreateEmptyView">CreateEmptyView() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.CreateEntity">CreateEntity() (in module ost.mol)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.CreateFullView">CreateFullView() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.CreateSequence">CreateSequence() (in module ost.seq)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.CreateViewFromAtomList">CreateViewFromAtomList() (in module ost.mol)</a></dt>
- <dt><a href="geom/vec.html#ost.geom.Cross">Cross() (in module ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Cuboid">Cuboid (class in ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis">CuboidAxis (class in ost.geom)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.Cut">Cut() (ost.seq.AlignmentHandle method)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="D">D</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/mat.html#ost.geom.Det">Det() (in module ost.geom)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.Difference">Difference() (in module ost.mol)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line2.direction">direction (ost.geom.Line2 attribute)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Line3.direction">(ost.geom.Line3 attribute)</a></dt>
- </dl></dd>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Distance">Distance() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.DoesPeptideBondExist">DoesPeptideBondExist() (ost.conop.Builder method)</a></dt>
- <dt><a href="geom/vec.html#ost.geom.Dot">Dot() (in module ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="E">E</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/editors.html#ost.mol.EditorBase">EditorBase (class in ost.mol)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2">Ellipse2 (class in ost.geom)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle">EntityHandle (class in ost.mol)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityView">EntityView (class in ost.mol)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Equal">Equal() (in module ost.geom)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/mat.html#ost.geom.EulerTransformation">EulerTransformation() (in module ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis.extent">extent (ost.geom.CuboidAxis attribute)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Mat4.ExtractRotation">ExtractRotation() (ost.geom.Mat4 method)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Mat4.ExtractTranslation">ExtractTranslation() (ost.geom.Mat4 method)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="F">F</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="img/alg/alg.html#ost.img.alg.FFT">FFT (class in ost.img.alg)</a></dt>
- <dt><a href="base/base.html#ost.settings.FileNotFound">FileNotFound</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.ChainHandle.FindAtom">FindAtom() (ost.mol.ChainHandle method)</a></dt>
- <dd><dl>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.FindAtom">(ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.ResidueHandle.FindAtom">(ost.mol.ResidueHandle method)</a></dt>
- </dl></dd>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.FindChain">FindChain() (ost.mol.EntityHandle method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/entity.html#ost.mol.ChainHandle.FindResidue">FindResidue() (ost.mol.ChainHandle method)</a></dt>
- <dd><dl>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.FindResidue">(ost.mol.EntityHandle method)</a></dt>
- </dl></dd>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.FindSequence">FindSequence() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.FindWithin">FindWithin() (ost.mol.EntityHandle method)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="G">G</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.gapless_string">gapless_string (ost.seq.SequenceHandle attribute)</a></dt>
- <dt><a href="img/alg/alg.html#ost.img.alg.GaussianFilter">GaussianFilter (class in ost.img.alg)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer">GenericPropertyContainer (built-in class)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.GetA">GetA() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Circle2.GetArea">GetArea() (ost.geom.Circle2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.GetArea">(ost.geom.Ellipse2 method)</a></dt>
- </dl></dd>
- <dt><a href="mol/base/entity.html#ost.mol.ChainHandle.GetAtomList">GetAtomList() (ost.mol.ChainHandle method)</a></dt>
- <dd><dl>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetAtomList">(ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.ResidueHandle.GetAtomList">(ost.mol.ResidueHandle method)</a></dt>
- </dl></dd>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetAttachedView">GetAttachedView() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.GetB">GetB() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.GetBoolProp">GetBoolProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.GetBoundingBox">GetBoundingBox() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Circle2.GetCenter">GetCenter() (ost.geom.Circle2 method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetCenterOfAtoms">GetCenterOfAtoms() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetCenterOfMass">GetCenterOfMass() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetChainList">GetChainList() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Circle2.GetCircumference">GetCircumference() (ost.geom.Circle2 method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.GetCount">GetCount() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line2.GetDirection">GetDirection() (ost.geom.Line2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Line3.GetDirection">(ost.geom.Line3 method)</a></dt>
- </dl></dd>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.GetEnd">GetEnd() (ost.geom.Rectangle2 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis.GetExtent">GetExtent() (ost.geom.CuboidAxis method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetFirstNonGap">GetFirstNonGap() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.GetFloatProp">GetFloatProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.GetGamma">GetGamma() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetGaplessString">GetGaplessString() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetGeometricCenter">GetGeometricCenter() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis.GetHalfExtent">GetHalfExtent() (ost.geom.CuboidAxis method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.GetHeight">GetHeight() (ost.geom.Rectangle2 method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="base/generic.html#GenericPropertyContainer.GetIntProp">GetIntProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetLastNonGap">GetLastNonGap() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.GetLength">GetLength() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="img/alg/alg.html#ost.img.alg.HighpassFilter.GetLimit">GetLimit() (ost.img.alg.HighpassFilter method)</a></dt>
- <dd><dl>
- <dt><a href="img/alg/alg.html#ost.img.alg.LowpassFilter.GetLimit">(ost.img.alg.LowpassFilter method)</a></dt>
- </dl></dd>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetMass">GetMass() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.AlignedCuboid.GetMax">GetMax() (ost.geom.AlignedCuboid method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.AlignedCuboid.GetMin">GetMin() (ost.geom.AlignedCuboid method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetName">GetName() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Plane.GetNormal">GetNormal() (ost.geom.Plane method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.GetOrigin">GetOrigin() (ost.geom.Ellipse2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Line2.GetOrigin">(ost.geom.Line2 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line3.GetOrigin">(ost.geom.Line3 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Plane.GetOrigin">(ost.geom.Plane method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Sphere.GetOrigin">(ost.geom.Sphere method)</a></dt>
- </dl></dd>
- <dt><a href="geom/composite.html#ost.geom.Plane.GetP">GetP() (ost.geom.Plane method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.GetPos">GetPos() (ost.seq.AlignmentHandle method)</a></dt>
- <dd><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetPos">(ost.seq.SequenceHandle method)</a></dt>
- </dl></dd>
- <dt><a href="base/generic.html#GenericPropertyContainer.GetPropAsString">GetPropAsString() (GenericPropertyContainer method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Circle2.GetRadius">GetRadius() (ost.geom.Circle2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Sphere.GetRadius">(ost.geom.Sphere method)</a></dt>
- </dl></dd>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.GetResidueIndex">GetResidueIndex() (ost.seq.AlignmentHandle method)</a></dt>
- <dd><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetResidueIndex">(ost.seq.SequenceHandle method)</a></dt>
- </dl></dd>
- <dt><a href="mol/base/entity.html#ost.mol.ChainHandle.GetResidueList">GetResidueList() (ost.mol.ChainHandle method)</a></dt>
- <dd><dl>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.GetResidueList">(ost.mol.EntityHandle method)</a></dt>
- </dl></dd>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.GetSequence">GetSequence() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.GetSequenceList">GetSequenceList() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.GetSequenceOffset">GetSequenceOffset() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.GetStart">GetStart() (ost.geom.Rectangle2 method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.GetStringProp">GetStringProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="base/base.html#ost.settings.GetValue">GetValue() (in module ost.settings)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis.GetVector">GetVector() (ost.geom.CuboidAxis method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.GetWidth">GetWidth() (ost.geom.Rectangle2 method)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.GuessAtomElement">GuessAtomElement() (ost.conop.Builder method)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="H">H</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis.half_extent">half_extent (ost.geom.CuboidAxis attribute)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.HasAttachedView">HasAttachedView() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.HasProp">HasProp() (GenericPropertyContainer method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.height">height (ost.geom.Rectangle2 attribute)</a></dt>
- <dt><a href="img/alg/alg.html#ost.img.alg.HighpassFilter">HighpassFilter (class in ost.img.alg)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="I">I</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/editors.html#ost.mol.ICSEditor">ICSEditor (class in ost.mol)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.IdentifyResidue">IdentifyResidue() (ost.conop.Builder method)</a></dt>
- <dd><dl>
- <dt><a href="conop/conop.html#ost.conop.RuleBasedBuilder.IdentifyResidue">(ost.conop.RuleBasedBuilder method)</a></dt>
- </dl></dd>
- <dt><a href="geom/mat.html#ost.geom.Mat2.Identity">Identity() (ost.geom.Mat2 static method)</a></dt>
- <dd><dl>
- <dt><a href="geom/mat.html#ost.geom.Mat3.Identity">(ost.geom.Mat3 static method)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Mat4.Identity">(ost.geom.Mat4 static method)</a></dt>
- </dl></dd>
- <dt><a href="mol/base/editors.html#ost.mol.EditorBase.InsertAtom">InsertAtom() (ost.mol.EditorBase method)</a></dt>
- <dt><a href="mol/base/editors.html#ost.mol.EditorBase.InsertChain">InsertChain() (ost.mol.EditorBase method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.Intersection">Intersection() (in module ost.mol)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.IntersectionLine">IntersectionLine() (in module ost.geom)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.IntersectionPoint">IntersectionPoint() (in module ost.geom)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Invert">Invert() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.IsBondFeasible">IsBondFeasible() (ost.conop.Builder method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.IsInPlane">IsInPlane() (in module ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.IsInSphere">IsInSphere() (in module ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.IsOnLine">IsOnLine() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.Builder.IsResidueComplete">IsResidueComplete() (ost.conop.Builder method)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="L">L</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Length">Length() (in module ost.geom)</a></dt>
- <dt><a href="geom/vec.html#ost.geom.Length2">Length2() (in module ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line2">Line2 (class in ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line3">Line3 (class in ost.geom)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="io/io.html#ost.io.LoadEntity">LoadEntity() (in module ost.io)</a></dt>
- <dt><a href="io/io.html#ost.io.LoadPDB">LoadPDB() (in module ost.io)</a></dt>
- <dt><a href="base/base.html#ost.settings.Locate">Locate() (in module ost.settings)</a></dt>
- <dt><a href="img/alg/alg.html#ost.img.alg.LowpassFilter">LowpassFilter (class in ost.img.alg)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="M">M</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/mat.html#ost.geom.Mat2">Mat2 (class in ost.geom)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Mat3">Mat3 (class in ost.geom)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/mat.html#ost.geom.Mat4">Mat4 (class in ost.geom)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Minor">Minor() (in module ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="N">N</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.name">name (ost.seq.SequenceHandle attribute)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Plane.normal">normal (ost.geom.Plane attribute)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Normalize">Normalize() (in module ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="O">O</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="conop/conop.html#ost.conop.RuleBasedBuilder.OnMissingAtom">OnMissingAtom() (ost.conop.RuleBasedBuilder method)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.RuleBasedBuilder.OnUnknownAtom">OnUnknownAtom() (ost.conop.RuleBasedBuilder method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Line2.origin">origin (ost.geom.Line2 attribute)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Line3.origin">(ost.geom.Line3 attribute)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Plane.origin">(ost.geom.Plane attribute)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Sphere.origin">(ost.geom.Sphere attribute)</a></dt>
- </dl></dd>
- <dt><a href="geom/mat.html#ost.geom.OrthogonalVector">OrthogonalVector() (in module ost.geom)</a></dt>
- <dt><a href="conop/conop.html#module-ost.conop">ost.conop (module)</a></dt>
- <dt><a href="geom/geom.html#module-ost.geom">ost.geom (module)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="img/base/img.html#module-ost.img">ost.img (module)</a></dt>
- <dt><a href="img/alg/alg.html#module-ost.img.alg">ost.img.alg (module)</a></dt>
- <dt><a href="io/io.html#module-ost.io">ost.io (module)</a></dt>
- <dt><a href="mol/base/mol.html#module-ost.mol">ost.mol (module)</a></dt>
- <dt><a href="seq/base/seq.html#module-ost.seq">ost.seq (module)</a></dt>
- <dt><a href="base/base.html#module-ost.settings">ost.settings (module)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="P">P</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Plane.p">p (ost.geom.Plane attribute)</a></dt>
- <dt><a href="geom/mat.html#ost.geom.Mat4.PasteRotation">PasteRotation() (ost.geom.Mat4 method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Plane">Plane (class in ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="Q">Q</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/query.html#Query">Query (built-in class)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="R">R</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Sphere.radius">radius (ost.geom.Sphere attribute)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2">Rectangle2 (class in ost.geom)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.Replace">Replace() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.RequestICSEditor">RequestICSEditor() (ost.mol.EntityHandle method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.RequestXCSEditor">RequestXCSEditor() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.ResidueHandle">ResidueHandle (class in ost.mol)</a></dt>
- <dt><a href="conop/conop.html#ost.conop.RuleBasedBuilder">RuleBasedBuilder (class in ost.conop)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="S">S</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="io/io.html#ost.io.SaveEntity">SaveEntity() (in module ost.io)</a></dt>
- <dt><a href="io/io.html#ost.io.SavePDB">SavePDB() (in module ost.io)</a></dt>
- <dt><a href="mol/base/entity.html#ost.mol.EntityHandle.Select">Select() (ost.mol.EntityHandle method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.sequence_offset">sequence_offset (ost.seq.SequenceHandle attribute)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle">SequenceHandle (class in ost.seq)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceList">SequenceList (class in ost.seq)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.SetA">SetA() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="mol/base/editors.html#ost.mol.XCSEditor.SetAtomPos">SetAtomPos() (ost.mol.XCSEditor method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.SetB">SetB() (ost.geom.Ellipse2 method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.SetBoolProp">SetBoolProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Circle2.SetCenter">SetCenter() (ost.geom.Circle2 method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.SetEnd">SetEnd() (ost.geom.Rectangle2 method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.SetFloatProp">SetFloatProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.SetGamma">SetGamma() (ost.geom.Ellipse2 method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="base/generic.html#GenericPropertyContainer.SetIntProp">SetIntProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="img/alg/alg.html#ost.img.alg.HighpassFilter.SetLimit">SetLimit() (ost.img.alg.HighpassFilter method)</a></dt>
- <dd><dl>
- <dt><a href="img/alg/alg.html#ost.img.alg.LowpassFilter.SetLimit">(ost.img.alg.LowpassFilter method)</a></dt>
- </dl></dd>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.SetName">SetName() (ost.seq.SequenceHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Ellipse2.SetOrigin">SetOrigin() (ost.geom.Ellipse2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Sphere.SetOrigin">(ost.geom.Sphere method)</a></dt>
- </dl></dd>
- <dt><a href="mol/base/editors.html#ost.mol.XCSEditor.SetOriginalAtomPos">SetOriginalAtomPos() (ost.mol.XCSEditor method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Circle2.SetRadius">SetRadius() (ost.geom.Circle2 method)</a></dt>
- <dd><dl>
- <dt><a href="geom/composite.html#ost.geom.Sphere.SetRadius">(ost.geom.Sphere method)</a></dt>
- </dl></dd>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.SetSequenceName">SetSequenceName() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.SetSequenceOffset">SetSequenceOffset() (ost.seq.AlignmentHandle method)</a></dt>
- <dd><dl>
- <dt><a href="seq/base/seq.html#ost.seq.SequenceHandle.SetSequenceOffset">(ost.seq.SequenceHandle method)</a></dt>
- </dl></dd>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.SetStart">SetStart() (ost.geom.Rectangle2 method)</a></dt>
- <dt><a href="base/generic.html#GenericPropertyContainer.SetStringProp">SetStringProp() (GenericPropertyContainer method)</a></dt>
- <dt><a href="mol/base/editors.html#ost.mol.XCSEditor.SetTransform">SetTransform() (ost.mol.XCSEditor method)</a></dt>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.ShiftRegion">ShiftRegion() (ost.seq.AlignmentHandle method)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.Sphere">Sphere (class in ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="T">T</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="seq/base/seq.html#ost.seq.AlignmentHandle.ToString">ToString() (ost.seq.AlignmentHandle method)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/mat.html#ost.geom.Transpose">Transpose() (in module ost.geom)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="U">U</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/entity.html#ost.mol.Union">Union() (in module ost.mol)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="V">V</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec2">Vec2 (class in ost.geom)</a></dt>
- <dt><a href="geom/vec.html#ost.geom.Vec3">Vec3 (class in ost.geom)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec4">Vec4 (class in ost.geom)</a></dt>
- <dt><a href="geom/composite.html#ost.geom.CuboidAxis.vector">vector (ost.geom.CuboidAxis attribute)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="W">W</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec4.w">w (ost.geom.Vec4 attribute)</a></dt>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/composite.html#ost.geom.Rectangle2.width">width (ost.geom.Rectangle2 attribute)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="X">X</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec2.x">x (ost.geom.Vec2 attribute)</a></dt>
- <dd><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec3.x">(ost.geom.Vec3 attribute)</a></dt>
- <dt><a href="geom/vec.html#ost.geom.Vec4.x">(ost.geom.Vec4 attribute)</a></dt>
- </dl></dd>
-</dl></td>
- <td width="33%" valign="top"><dl>
- <dt><a href="mol/base/editors.html#ost.mol.XCSEditor">XCSEditor (class in ost.mol)</a></dt>
-</dl></td>
-</tr></table>
-
-<h2 id="Y">Y</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec2.y">y (ost.geom.Vec2 attribute)</a></dt>
- <dd><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec3.y">(ost.geom.Vec3 attribute)</a></dt>
- <dt><a href="geom/vec.html#ost.geom.Vec4.y">(ost.geom.Vec4 attribute)</a></dt>
- </dl></dd>
-</dl></td>
-</tr></table>
-
-<h2 id="Z">Z</h2>
-<table width="100%" class="indextable genindextable"><tr>
- <td width="33%" valign="top"><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec3.z">z (ost.geom.Vec3 attribute)</a></dt>
- <dd><dl>
- <dt><a href="geom/vec.html#ost.geom.Vec4.z">(ost.geom.Vec4 attribute)</a></dt>
- </dl></dd>
-</dl></td>
-</tr></table>
-
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="#" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/geom/composite.html b/doc/build/geom/composite.html
deleted file mode 100644
index 41f80f611594b1ff1ceac3992e905d641fe85a09..0000000000000000000000000000000000000000
--- a/doc/build/geom/composite.html
+++ /dev/null
@@ -1,1120 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Geometric Objects — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="up" title="geom – vectors, matrices and geometrical objects" href="geom.html" />
- <link rel="next" title="conop – Connectivity and Topology of Molecules" href="../conop/conop.html" />
- <link rel="prev" title="Matrices" href="mat.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../conop/conop.html" title="conop – Connectivity and Topology of Molecules"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="mat.html" title="Matrices"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="geom.html" accesskey="U"><tt class="docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Geometric Objects</a><ul>
-<li><a class="reference internal" href="#geometrical-objects-in-two-dimensions">Geometrical Objects in Two Dimensions</a></li>
-<li><a class="reference internal" href="#geometrical-objects-in-three-dimensions">Geometrical Objects in Three Dimensions</a></li>
-<li><a class="reference internal" href="#operations-on-geometrical-objects">Operations on Geometrical Objects</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="mat.html"
- title="previous chapter">Matrices</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../conop/conop.html"
- title="next chapter"><tt class="docutils literal docutils literal"><span class="pre">conop</span></tt> – Connectivity and Topology of Molecules</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/geom/composite.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="geometric-objects">
-<h1>Geometric Objects<a class="headerlink" href="#geometric-objects" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="geometrical-objects-in-two-dimensions">
-<h2>Geometrical Objects in Two Dimensions<a class="headerlink" href="#geometrical-objects-in-two-dimensions" title="Permalink to this headline">¶</a></h2>
-<dl class="class">
-<dt id="ost.geom.Line2">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Line2</tt><a class="headerlink" href="#ost.geom.Line2" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Line2</tt><big>(</big><em>from</em>, <em>to</em><big>)</big></dt>
-<dd><p>Parametric line in two dimensions as defined by an origin and a normalized
-direction vector. The first constructor creates a line with origin (0,0) and
-direction along the x axis. The second signature creates a line originating
-from <cite>from</cite> and pointing towards <cite>to</cite>.</p>
-<dl class="method">
-<dt id="ost.geom.Line2.At">
-<tt class="descname">At</tt><big>(</big><em>t</em><big>)</big><a class="headerlink" href="#ost.geom.Line2.At" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the point on the line at (signed) distance t from origin.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>t</strong> – free parameter</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><pending_xref py:class=”Line2” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec2” reftype=”class”><literal classes=”xref py py-class”>Vec2</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Line2.GetOrigin">
-<tt class="descname">GetOrigin</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Line2.GetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the origin of the line: Also available as <a class="reference internal" href="#ost.geom.Line2.origin" title="ost.geom.Line2.origin"><tt class="xref py py-attr docutils literal"><span class="pre">origin</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Line2” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec2” reftype=”class”><literal classes=”xref py py-class”>Vec2</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Line2.GetDirection">
-<tt class="descname">GetDirection</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Line2.GetDirection" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the normalized direction vector. Also available as
-<a class="reference internal" href="#ost.geom.Line2.direction" title="ost.geom.Line2.direction"><tt class="xref py py-attr docutils literal"><span class="pre">direction</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Line2” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec2” reftype=”class”><literal classes=”xref py py-class”>Vec2</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Line2.direction">
-<tt class="descname">direction</tt><a class="headerlink" href="#ost.geom.Line2.direction" title="Permalink to this definition">¶</a></dt>
-<dd></dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Line2.origin">
-<tt class="descname">origin</tt><a class="headerlink" href="#ost.geom.Line2.origin" title="Permalink to this definition">¶</a></dt>
-<dd></dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Rectangle2">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Rectangle2</tt><a class="headerlink" href="#ost.geom.Rectangle2" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Rectangle2</tt><big>(</big><em>top_left</em>, <em>bottom_right</em><big>)</big></dt>
-<dd><p>Axis aligned rectangle. The first signature creates a rectangle with top-left
-corner (-1, -1) and bottom-right corner (1, 1), wheras the second method
-allows to set the top-left and bottom-right corners directly.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>top_left</strong> (<em>Vec2</em>) – The top-left corner</li>
-<li><strong>bottom_right</strong> (<em>Vec2</em>) – The bottom-right corner</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="method">
-<dt id="ost.geom.Rectangle2.GetWidth">
-<tt class="descname">GetWidth</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Rectangle2.GetWidth" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the width of the rectangle. Also available as <a class="reference internal" href="#ost.geom.Rectangle2.width" title="ost.geom.Rectangle2.width"><tt class="xref py py-attr docutils literal"><span class="pre">width</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Rectangle2.GetHeight">
-<tt class="descname">GetHeight</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Rectangle2.GetHeight" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the height of the rectangle. Also available as <a class="reference internal" href="#ost.geom.Rectangle2.height" title="ost.geom.Rectangle2.height"><tt class="xref py py-attr docutils literal"><span class="pre">height</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Rectangle2.width">
-<tt class="descname">width</tt><a class="headerlink" href="#ost.geom.Rectangle2.width" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Rectangle2.height">
-<tt class="descname">height</tt><a class="headerlink" href="#ost.geom.Rectangle2.height" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Rectangle2.GetStart">
-<tt class="descname">GetStart</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Rectangle2.GetStart" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get top-left corner</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Rectangle2” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec2” reftype=”class”><literal classes=”xref py py-class”>Vec2</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Rectangle2.GetEnd">
-<tt class="descname">GetEnd</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Rectangle2.GetEnd" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get bottom-right corner</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Rectangle2” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec2” reftype=”class”><literal classes=”xref py py-class”>Vec2</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Rectangle2.SetStart">
-<tt class="descname">SetStart</tt><big>(</big><em>top_left</em><big>)</big><a class="headerlink" href="#ost.geom.Rectangle2.SetStart" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set top-left corner, leaving the bottom-right corner untouched.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Rectangle2.SetEnd">
-<tt class="descname">SetEnd</tt><big>(</big><em>bottom_right</em><big>)</big><a class="headerlink" href="#ost.geom.Rectangle2.SetEnd" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the bottom-right corner, leaving the top-left corner untouched.</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Circle2">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Circle2</tt><a class="headerlink" href="#ost.geom.Circle2" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Circle2</tt><big>(</big><em>circle</em><big>)</big></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Circle2</tt><big>(</big><em>center</em>, <em>radius</em><big>)</big></dt>
-<dd><p>The first signature creates a circle centered at (0, 0) and radius 1.0. The
-second signature creates a circle with the same paramters as <cite>circle</cite>. The
-third signature creates a new circle with given center and radius.</p>
-<dl class="method">
-<dt id="ost.geom.Circle2.SetCenter">
-<tt class="descname">SetCenter</tt><big>(</big><em>center</em><big>)</big><a class="headerlink" href="#ost.geom.Circle2.SetCenter" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set center of circle</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>center</strong> (<em>Vec2</em>) – The new center</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Circle2.SetRadius">
-<tt class="descname">SetRadius</tt><big>(</big><em>radius</em><big>)</big><a class="headerlink" href="#ost.geom.Circle2.SetRadius" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set radius of circle</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>center</strong> – The new radius</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Circle2.GetCenter">
-<tt class="descname">GetCenter</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Circle2.GetCenter" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the center of the circle</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Circle2.GetRadius">
-<tt class="descname">GetRadius</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Circle2.GetRadius" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the radius of the circle</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Circle2.GetArea">
-<tt class="descname">GetArea</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Circle2.GetArea" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the area of the circle</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Circle2.GetCircumference">
-<tt class="descname">GetCircumference</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Circle2.GetCircumference" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the circumference of the circle</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Ellipse2">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Ellipse2</tt><a class="headerlink" href="#ost.geom.Ellipse2" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Ellipse2</tt><big>(</big><em>center</em>, <em>a</em>, <em>b</em>, <em>gamma</em><big>)</big></dt>
-<dd><p>An ellipse is defined by a center, two principal axis and gamma that
-defines the angle between the first principal axis an the x-axis.</p>
-<dl class="method">
-<dt id="ost.geom.Ellipse2.At">
-<tt class="descname">At</tt><big>(</big><em>t</em><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.At" title="Permalink to this definition">¶</a></dt>
-<dd><p>?</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.AtAngle">
-<tt class="descname">AtAngle</tt><big>(</big><em>angle</em><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.AtAngle" title="Permalink to this definition">¶</a></dt>
-<dd><p>?</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.GetBoundingBox">
-<tt class="descname">GetBoundingBox</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.GetBoundingBox" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the bounding rectangle (axis-aligned) of the ellipse</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Ellipse2” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Rectangle2” reftype=”class”><literal classes=”xref py py-class”>Rectangle2</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.GetA">
-<tt class="descname">GetA</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.GetA" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the first principal-axis</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.GetB">
-<tt class="descname">GetB</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.GetB" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the second principal-axis</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.GetGamma">
-<tt class="descname">GetGamma</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.GetGamma" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the angle of the first principal axis to the x-axis</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.GetArea">
-<tt class="descname">GetArea</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.GetArea" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the area of the ellipse</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.GetOrigin">
-<tt class="descname">GetOrigin</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.GetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the center of the ellipse</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.SetA">
-<tt class="descname">SetA</tt><big>(</big><em>a</em><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.SetA" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the length of the first principal axis</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.SetB">
-<tt class="descname">SetB</tt><big>(</big><em>b</em><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.SetB" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the length of the second principal axis</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.SetGamma">
-<tt class="descname">SetGamma</tt><big>(</big><em>gamma</em><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.SetGamma" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the angle of the first principal axis to the x-axis</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Ellipse2.SetOrigin">
-<tt class="descname">SetOrigin</tt><big>(</big><em>ori</em><big>)</big><a class="headerlink" href="#ost.geom.Ellipse2.SetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the center of the ellipse</p>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="geometrical-objects-in-three-dimensions">
-<h2>Geometrical Objects in Three Dimensions<a class="headerlink" href="#geometrical-objects-in-three-dimensions" title="Permalink to this headline">¶</a></h2>
-<dl class="class">
-<dt id="ost.geom.Line3">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Line3</tt><a class="headerlink" href="#ost.geom.Line3" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Line3</tt><big>(</big><em>from</em>, <em>to</em><big>)</big></dt>
-<dd><p>Parametric line in three dimensions as defined by an origin and a normalized
-direction vector. The first constructor creates a line with origin (0,0) and
-direction along the x axis. The second signature creates a line originating
-from <cite>from</cite> and pointing towards <cite>to</cite>.</p>
-<dl class="method">
-<dt id="ost.geom.Line3.At">
-<tt class="descname">At</tt><big>(</big><em>t</em><big>)</big><a class="headerlink" href="#ost.geom.Line3.At" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the point on the line at (signed) distance t from origin.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>t</strong> – free parameter</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><pending_xref py:class=”Line3” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Line3.GetOrigin">
-<tt class="descname">GetOrigin</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Line3.GetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the origin of the line: Also available as <a class="reference internal" href="#ost.geom.Line3.origin" title="ost.geom.Line3.origin"><tt class="xref py py-attr docutils literal"><span class="pre">origin</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Line3” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Line3.GetDirection">
-<tt class="descname">GetDirection</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Line3.GetDirection" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the normalized direction vector. Also available as
-<a class="reference internal" href="#ost.geom.Line3.direction" title="ost.geom.Line3.direction"><tt class="xref py py-attr docutils literal"><span class="pre">direction</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Line3” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Line3.direction">
-<tt class="descname">direction</tt><a class="headerlink" href="#ost.geom.Line3.direction" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Line3.origin">
-<tt class="descname">origin</tt><a class="headerlink" href="#ost.geom.Line3.origin" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Plane">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Plane</tt><a class="headerlink" href="#ost.geom.Plane" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Plane</tt><big>(</big><em>p1</em>, <em>p2</em>, <em>p3</em><big>)</big></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Plane</tt><big>(</big><em>x</em>, <em>y</em>, <em>z</em>, <em>p</em><big>)</big></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Plane</tt><big>(</big><em>line</em>, <em>point</em><big>)</big></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Plane</tt><big>(</big><em>point</em>, <em>normal</em><big>)</big></dt>
-<dd><p>A plane in 3d-space. The plane can be constructed by either passing in 3
-points (p1, p2, p3), a normal and a point, the four parameters that define the
-implicit plane equation (<cite>x</cite>, <cite>y</cite>, <cite>z</cite>, <cite>p</cite>) or a line and a point.</p>
-<dl class="method">
-<dt id="ost.geom.Plane.GetNormal">
-<tt class="descname">GetNormal</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Plane.GetNormal" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the normal of the plane. Also available as <a class="reference internal" href="#ost.geom.Plane.normal" title="ost.geom.Plane.normal"><tt class="xref py py-attr docutils literal"><span class="pre">normal</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Plane” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Plane.GetP">
-<tt class="descname">GetP</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Plane.GetP" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the plane offset, i.e. the projection of any point on the plane onto
-the normal. Also available as <a class="reference internal" href="#ost.geom.Plane.p" title="ost.geom.Plane.p"><tt class="xref py py-attr docutils literal"><span class="pre">p</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Plane.GetOrigin">
-<tt class="descname">GetOrigin</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Plane.GetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get the origin of the plane. Also available as <a class="reference internal" href="#ost.geom.Plane.origin" title="ost.geom.Plane.origin"><tt class="xref py py-attr docutils literal"><span class="pre">origin</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”Plane” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Plane.origin">
-<tt class="descname">origin</tt><a class="headerlink" href="#ost.geom.Plane.origin" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Plane.normal">
-<tt class="descname">normal</tt><a class="headerlink" href="#ost.geom.Plane.normal" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Plane.p">
-<tt class="descname">p</tt><a class="headerlink" href="#ost.geom.Plane.p" title="Permalink to this definition">¶</a></dt>
-<dd><table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Sphere">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Sphere</tt><a class="headerlink" href="#ost.geom.Sphere" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Sphere</tt><big>(</big><em>center</em>, <em>radius</em><big>)</big></dt>
-<dd><p>Represents a sphere in 3d space. The first constructor creates a sphere with
-radius 1, centered at (0, 0, 0), the second allows you to set the radius and
-center directly.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>center</strong> (<em>Vec3</em>) – The center</li>
-<li><strong>radius</strong> – The radius</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="attribute">
-<dt id="ost.geom.Sphere.radius">
-<tt class="descname">radius</tt><a class="headerlink" href="#ost.geom.Sphere.radius" title="Permalink to this definition">¶</a></dt>
-<dd><p>The radius of the sphere. Read-write. Also available as <a class="reference internal" href="#ost.geom.Sphere.GetRadius" title="ost.geom.Sphere.GetRadius"><tt class="xref py py-meth docutils literal"><span class="pre">GetRadius()</span></tt></a>,
-<a class="reference internal" href="#ost.geom.Sphere.SetRadius" title="ost.geom.Sphere.SetRadius"><tt class="xref py py-meth docutils literal"><span class="pre">SetRadius()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Sphere.origin">
-<tt class="descname">origin</tt><a class="headerlink" href="#ost.geom.Sphere.origin" title="Permalink to this definition">¶</a></dt>
-<dd><p>The center of the sphere. Read-write. Also available as <a class="reference internal" href="#ost.geom.Sphere.GetOrigin" title="ost.geom.Sphere.GetOrigin"><tt class="xref py py-meth docutils literal"><span class="pre">GetOrigin()</span></tt></a>,
-<a class="reference internal" href="#ost.geom.Sphere.SetOrigin" title="ost.geom.Sphere.SetOrigin"><tt class="xref py py-meth docutils literal"><span class="pre">SetOrigin()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Sphere.GetOrigin">
-<tt class="descname">GetOrigin</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Sphere.GetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.Sphere.origin" title="ost.geom.Sphere.origin"><tt class="xref py py-attr docutils literal"><span class="pre">origin</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Sphere.SetOrigin">
-<tt class="descname">SetOrigin</tt><big>(</big><em>origin</em><big>)</big><a class="headerlink" href="#ost.geom.Sphere.SetOrigin" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.Sphere.origin" title="ost.geom.Sphere.origin"><tt class="xref py py-attr docutils literal"><span class="pre">origin</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Sphere.GetRadius">
-<tt class="descname">GetRadius</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Sphere.GetRadius" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.Sphere.radius" title="ost.geom.Sphere.radius"><tt class="xref py py-attr docutils literal"><span class="pre">radius</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Sphere.SetRadius">
-<tt class="descname">SetRadius</tt><big>(</big><em>radius</em><big>)</big><a class="headerlink" href="#ost.geom.Sphere.SetRadius" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.Sphere.radius" title="ost.geom.Sphere.radius"><tt class="xref py py-attr docutils literal"><span class="pre">radius</span></tt></a></p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.AlignedCuboid">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">AlignedCuboid</tt><big>(</big><em>min</em>, <em>max</em><big>)</big><a class="headerlink" href="#ost.geom.AlignedCuboid" title="Permalink to this definition">¶</a></dt>
-<dd><p>Axis aligned cuboid is a cuboid whose axes are aligned to the x-, y-, and z-
-axes of the coordinate system. For arbitrarily oriented bounding cuboid
-class, see <a class="reference internal" href="#ost.geom.Cuboid" title="ost.geom.Cuboid"><tt class="xref py py-class docutils literal"><span class="pre">Cuboid</span></tt></a>.</p>
-<dl class="method">
-<dt id="ost.geom.AlignedCuboid.GetMin">
-<tt class="descname">GetMin</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.AlignedCuboid.GetMin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get minimum coordinate, i.e. the lower bound of x-, y-, and z for
-any point in the cuboid</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”AlignedCuboid” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.AlignedCuboid.GetMax">
-<tt class="descname">GetMax</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.AlignedCuboid.GetMax" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get maximum coordinate, i.e. the upper bound of x-, y-, and z for
-any point in the cuboid.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><pending_xref py:class=”AlignedCuboid” py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.CuboidAxis">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">CuboidAxis</tt><a class="headerlink" href="#ost.geom.CuboidAxis" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">CuboidAxis</tt><big>(</big><em>dir</em>, <em>half_extent</em><big>)</big></dt>
-<dd><p>A cuboid axis is defined by a half-extent, and a direction vector. This class
-is used in together with the <a class="reference internal" href="#ost.geom.Cuboid" title="ost.geom.Cuboid"><tt class="xref py py-class docutils literal"><span class="pre">Cuboid</span></tt></a> class.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>dir</strong> (<em>Vec3</em>) – Direction vector, will be normalized</li>
-<li><strong>half_extent</strong> – The half extent</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="attribute">
-<dt id="ost.geom.CuboidAxis.vector">
-<tt class="descname">vector</tt><a class="headerlink" href="#ost.geom.CuboidAxis.vector" title="Permalink to this definition">¶</a></dt>
-<dd><p>The normalized direction vector of the cuboid axis. Also available as
-<a class="reference internal" href="#ost.geom.CuboidAxis.GetVector" title="ost.geom.CuboidAxis.GetVector"><tt class="xref py py-meth docutils literal"><span class="pre">GetVector()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.CuboidAxis.half_extent">
-<tt class="descname">half_extent</tt><a class="headerlink" href="#ost.geom.CuboidAxis.half_extent" title="Permalink to this definition">¶</a></dt>
-<dd><p>The half extent of the cuboid axis is the magnitude of the cuboid
-axis measured from the center to the corner. Also available as
-<a class="reference internal" href="#ost.geom.CuboidAxis.GetHalfExtent" title="ost.geom.CuboidAxis.GetHalfExtent"><tt class="xref py py-meth docutils literal"><span class="pre">GetHalfExtent()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.CuboidAxis.extent">
-<tt class="descname">extent</tt><a class="headerlink" href="#ost.geom.CuboidAxis.extent" title="Permalink to this definition">¶</a></dt>
-<dd><p>The extent of the cuboid axis. This value is always twice the
-<a class="reference internal" href="#ost.geom.CuboidAxis.half_extent" title="ost.geom.CuboidAxis.half_extent"><tt class="xref py py-attr docutils literal"><span class="pre">half_extent</span></tt></a>. Read-only. Also available as
-<a class="reference internal" href="#ost.geom.CuboidAxis.GetExtent" title="ost.geom.CuboidAxis.GetExtent"><tt class="xref py py-meth docutils literal"><span class="pre">GetExtent()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.CuboidAxis.GetHalfExtent">
-<tt class="descname">GetHalfExtent</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.CuboidAxis.GetHalfExtent" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.CuboidAxis.half_extent" title="ost.geom.CuboidAxis.half_extent"><tt class="xref py py-attr docutils literal"><span class="pre">half_extent</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.CuboidAxis.GetExtent">
-<tt class="descname">GetExtent</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.CuboidAxis.GetExtent" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.CuboidAxis.extent" title="ost.geom.CuboidAxis.extent"><tt class="xref py py-attr docutils literal"><span class="pre">extent</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.CuboidAxis.GetVector">
-<tt class="descname">GetVector</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.CuboidAxis.GetVector" title="Permalink to this definition">¶</a></dt>
-<dd><p>See <a class="reference internal" href="#ost.geom.CuboidAxis.vector" title="ost.geom.CuboidAxis.vector"><tt class="xref py py-attr docutils literal"><span class="pre">vector</span></tt></a></p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Cuboid">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Cuboid</tt><big>(</big><em>center</em>, <em>axis_a</em>, <em>axis_b</em>, <em>axis_c</em><big>)</big><a class="headerlink" href="#ost.geom.Cuboid" title="Permalink to this definition">¶</a></dt>
-<dd><p>An arbitrarily oriented cuboid defined by a center and 3 axis. The 3 cuboid
-axis are stored in the order they are passed to the constructor. This means,
-that there is no guarantee that the 3 axes form a right-handed coordinate
-system. If a right-handed coordinate system is a requirement, you have to
-ensure this on your own:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">center</span><span class="o">=...</span>
-<span class="n">axis_a</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">CuboidAxis</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
-<span class="n">axis_b</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">CuboidAxis</span><span class="p">(</span><span class="o">...</span><span class="p">)</span>
-<span class="n">axis_c</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">CuboidAxis</span><span class="p">(</span><span class="n">geom</span><span class="o">.</span><span class="n">Cross</span><span class="p">(</span><span class="n">axis_a</span><span class="o">.</span><span class="n">vector</span><span class="p">,</span> <span class="n">axis_b</span><span class="o">.</span><span class="n">vector</span><span class="p">),</span> <span class="o">...</span><span class="p">)</span>
-
-<span class="n">cuboid</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">Cuboid</span><span class="p">(</span><span class="n">center</span><span class="p">,</span> <span class="n">axis_a</span><span class="p">,</span> <span class="n">axis_b</span><span class="p">,</span> <span class="n">axis_c</span><span class="p">)</span>
-</pre></div>
-</div>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>center</strong> (<em>Vec3</em>) – The center</li>
-<li><strong>axis_a</strong> (<em>CuboidAxis</em>) – The first axis</li>
-<li><strong>axis_b</strong> (<em>CuboidAxis</em>) – The second axis</li>
-<li><strong>axis_c</strong> (<em>CuboidAxis</em>) – The third axis</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="attribute">
-<dt id="ost.geom.Cuboid.center">
-<tt class="descname">center</tt><a class="headerlink" href="#ost.geom.Cuboid.center" title="Permalink to this definition">¶</a></dt>
-<dd><p>The center of the cuboid.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="vec.html#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Cuboid.axis_a">
-<tt class="descname">axis_a</tt><a class="headerlink" href="#ost.geom.Cuboid.axis_a" title="Permalink to this definition">¶</a></dt>
-<dd><p>The first cuboid axis</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="#ost.geom.CuboidAxis" title="ost.geom.CuboidAxis"><tt class="xref py py-class docutils literal"><span class="pre">CuboidAxis</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Cuboid.axis_b">
-<tt class="descname">axis_b</tt><a class="headerlink" href="#ost.geom.Cuboid.axis_b" title="Permalink to this definition">¶</a></dt>
-<dd><p>The second cuboid axis</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="#ost.geom.CuboidAxis" title="ost.geom.CuboidAxis"><tt class="xref py py-class docutils literal"><span class="pre">CuboidAxis</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Cuboid.axis_c">
-<tt class="descname">axis_c</tt><a class="headerlink" href="#ost.geom.Cuboid.axis_c" title="Permalink to this definition">¶</a></dt>
-<dd><p>The third cuboid axis</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body"><a class="reference internal" href="#ost.geom.CuboidAxis" title="ost.geom.CuboidAxis"><tt class="xref py py-class docutils literal"><span class="pre">CuboidAxis</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="operations-on-geometrical-objects">
-<h2>Operations on Geometrical Objects<a class="headerlink" href="#operations-on-geometrical-objects" title="Permalink to this headline">¶</a></h2>
-<dl class="function">
-<dt id="ost.geom.Angle">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Angle</tt><big>(</big><em>lhs</em>, <em>rhs</em><big>)</big><a class="headerlink" href="#ost.geom.Angle" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculate the angle (in radians) between <cite>lhs</cite> and <cite>rhs</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>lhs</strong> (<em>Line2Line3Plane</em>) – First object</li>
-<li><strong>rhs</strong> (<em>Line2Line3Plane</em>) – Second object</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">float</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.IntersectionPoint">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">IntersectionPoint</tt><big>(</big><em>lhs</em>, <em>rhs</em><big>)</big><a class="headerlink" href="#ost.geom.IntersectionPoint" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates and returns the intersection point between <cite>lhs</cite> and <cite>rhs</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>lhs</strong> (<em>Line2Line3Plane</em>) – First object</li>
-<li><strong>rhs</strong> (<em>Line2Line3Plane</em>) – Second object</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first"><tt class="xref py py-exc docutils literal"><span class="pre">GeomException</span></tt> when the two objects do not intersect</p>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last"><pending_xref py:class py:module=”ost.geom” refdoc=”geom/composite” refdomain=”py” refexplicit=”False” reftarget=”Vec3” reftype=”class”><literal classes=”xref py py-class”>Vec3</literal></pending_xref> (<a class="reference internal" href="vec.html#ost.geom.Vec2" title="ost.geom.Vec2"><tt class="xref py py-class docutils literal"><span class="pre">Vec2</span></tt></a> in case of <a class="reference internal" href="#ost.geom.Line2" title="ost.geom.Line2"><tt class="xref py py-class docutils literal"><span class="pre">Line2</span></tt></a>)</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.IntersectionLine">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">IntersectionLine</tt><big>(</big><em>plane2</em>, <em>plane2</em><big>)</big><a class="headerlink" href="#ost.geom.IntersectionLine" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the intersection line between <cite>plane1</cite> and <cite>plane2</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>plane1</strong> (<em>Plane</em>) – The first plane</li>
-<li><strong>plane2</strong> (<em>Plane</em>) – The second plane</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first last">:exc:GeomException if the two planes are parallel.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Distance">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Distance</tt><big>(</big><em>lhs</em>, <em>rhs</em><big>)</big><a class="headerlink" href="#ost.geom.Distance" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the minimal distance between <cite>lhs</cite> and <cite>rhs</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>lhs</strong> (<em>Line2Line3Plane</em>) – First object</li>
-<li><strong>rhs</strong> (<em>Line2Line3Plane</em>) – Second object</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">float</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.IsOnLine">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">IsOnLine</tt><big>(</big><em>line</em>, <em>point</em>, <em>epsilon=geom.EPSILON</em><big>)</big><a class="headerlink" href="#ost.geom.IsOnLine" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check whether <cite>point</cite> lies on <cite>line</cite> and returns true if point i no further
-away than <cite>epsilon</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body">bool</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.IsInPlane">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">IsInPlane</tt><big>(</big><em>plane</em>, <em>object</em>, <em>epsilon=geom.EPSILON</em><big>)</big><a class="headerlink" href="#ost.geom.IsInPlane" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check whether <cite>object</cite> lies in <cite>plane</cite> and returns true if the difference is
-no bigger than <cite>epsilon</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>plane</strong> (<em>Plane</em>) – The plane</li>
-<li><strong>object</strong> (<em>Vec3Line3</em>) – The object</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">bool</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.AreParallel">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">AreParallel</tt><big>(</big><em>lhs</em>, <em>rhs</em>, <em>epsilon=geom.EPSILON</em><big>)</big><a class="headerlink" href="#ost.geom.AreParallel" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check whether <cite>lhs</cite> and <cite>rhs</cite> are parallel and returns true, if the difference
-is below the given treshold <cite>epsilon</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>lhs</strong> (<em>Line2Line3Plane</em>) – First object</li>
-<li><strong>rhs</strong> (<em>Line2Line3Plane</em>) – Second object</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">bool</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.AreIntersecting">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">AreIntersecting</tt><big>(</big><em>line1</em>, <em>line2</em>, <em>epsilon=geom.EPSILON</em><big>)</big><a class="headerlink" href="#ost.geom.AreIntersecting" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check whether <cite>line1</cite> and <cite>line2</cite> are intersecting and returns true, if they
-intersect below the given threshold <cite>epsilon</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>lhs</strong> (<em>Line2Line3</em>) – First line</li>
-<li><strong>rhs</strong> (<em>Line2Line3</em>) – Second line</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first last">bool</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.IsInSphere">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">IsInSphere</tt><big>(</big><em>sphere</em>, <em>point</em><big>)</big><a class="headerlink" href="#ost.geom.IsInSphere" title="Permalink to this definition">¶</a></dt>
-<dd><p>Check whether the <cite>sphere</cite> contains <cite>point</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body">bool</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../conop/conop.html" title="conop – Connectivity and Topology of Molecules"
- >next</a> |</li>
- <li class="right" >
- <a href="mat.html" title="Matrices"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="geom.html" ><tt class="docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/geom/geom.html b/doc/build/geom/geom.html
deleted file mode 100644
index a0786536eea104d723b5d709128cdc786b94dc87..0000000000000000000000000000000000000000
--- a/doc/build/geom/geom.html
+++ /dev/null
@@ -1,137 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>geom – vectors, matrices and geometrical objects — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="next" title="Vectors" href="vec.html" />
- <link rel="prev" title="alg - Image Processing Algorithms" href="../img/alg/alg.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="vec.html" title="Vectors"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../img/alg/alg.html" title="alg - Image Processing Algorithms"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h4>Previous topic</h4>
- <p class="topless"><a href="../img/alg/alg.html"
- title="previous chapter"><tt class="docutils literal"><span class="pre">alg</span></tt> - Image Processing Algorithms</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="vec.html"
- title="next chapter">Vectors</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/geom/geom.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.geom">
-<span id="geom-vectors-matrices-and-geometrical-objects"></span><h1><a class="reference internal" href="#module-ost.geom" title="Functions and classes for vectors, matrices and geometrical objects in 2, 3 and four dimensions"><tt class="xref py py-mod docutils literal"><span class="pre">geom</span></tt></a> – vectors, matrices and geometrical objects<a class="headerlink" href="#module-ost.geom" title="Permalink to this headline">¶</a></h1>
-<p>The geom modules contains functions and classes for vectors, matrices and other
-geometrical objects in 2, 3 and four dimensions.</p>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="vec.html">Vectors</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="vec.html#vector-classes">Vector Classes</a></li>
-<li class="toctree-l2"><a class="reference internal" href="vec.html#functions-operating-on-vectors">Functions Operating on Vectors</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="mat.html">Matrices</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="mat.html#the-matrix-classes">The Matrix Classes</a></li>
-<li class="toctree-l2"><a class="reference internal" href="mat.html#functions-operating-on-matrices">Functions Operating on Matrices</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="composite.html">Geometric Objects</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="composite.html#geometrical-objects-in-two-dimensions">Geometrical Objects in Two Dimensions</a></li>
-<li class="toctree-l2"><a class="reference internal" href="composite.html#geometrical-objects-in-three-dimensions">Geometrical Objects in Three Dimensions</a></li>
-<li class="toctree-l2"><a class="reference internal" href="composite.html#operations-on-geometrical-objects">Operations on Geometrical Objects</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="vec.html" title="Vectors"
- >next</a> |</li>
- <li class="right" >
- <a href="../img/alg/alg.html" title="alg - Image Processing Algorithms"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/geom/mat.html b/doc/build/geom/mat.html
deleted file mode 100644
index abc6826fd17aa74711a64c682433eaac240e6404..0000000000000000000000000000000000000000
--- a/doc/build/geom/mat.html
+++ /dev/null
@@ -1,371 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Matrices — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="up" title="geom – vectors, matrices and geometrical objects" href="geom.html" />
- <link rel="next" title="Geometric Objects" href="composite.html" />
- <link rel="prev" title="Vectors" href="vec.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="composite.html" title="Geometric Objects"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="vec.html" title="Vectors"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="geom.html" accesskey="U"><tt class="docutils literal docutils literal docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Matrices</a><ul>
-<li><a class="reference internal" href="#the-matrix-classes">The Matrix Classes</a></li>
-<li><a class="reference internal" href="#functions-operating-on-matrices">Functions Operating on Matrices</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="vec.html"
- title="previous chapter">Vectors</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="composite.html"
- title="next chapter">Geometric Objects</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/geom/mat.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="matrices">
-<h1>Matrices<a class="headerlink" href="#matrices" title="Permalink to this headline">¶</a></h1>
-<p>The <a class="reference internal" href="geom.html#module-ost.geom" title="Functions and classes for vectors, matrices and geometrical objects in 2, 3 and four dimensions"><tt class="xref py py-mod docutils literal"><span class="pre">geom</span></tt></a> module defines matrices in two, three and four dimensions.
-All matrices store the values in row-major order, meaning that, the matrix ((1,
-2), (3,4)) stores the values as (1, 2, 3, 4). This is illustrated in
-the following code examples:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">m</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">Mat2</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">2</span><span class="p">,</span> <span class="mf">3</span><span class="p">,</span> <span class="mf">4</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">m</span> <span class="c"># will print {{1,2},{3,4}}</span>
-<span class="k">print</span> <span class="n">m</span><span class="p">[(</span><span class="mf">0</span><span class="p">,</span><span class="mf">0</span><span class="p">)],</span> <span class="n">m</span><span class="p">[(</span><span class="mf">0</span><span class="p">,</span><span class="mf">1</span><span class="p">)],</span> <span class="n">m</span><span class="p">[(</span><span class="mf">1</span><span class="p">,</span><span class="mf">0</span><span class="p">)],</span> <span class="n">m</span><span class="p">[(</span><span class="mf">1</span><span class="p">,</span><span class="mf">1</span><span class="p">)]</span> <span class="c"># will print 1, 2, 3, 4</span>
-</pre></div>
-</div>
-<p>Matrices support arithmetic via overloaded operators. The following operations are
-supported:</p>
-<blockquote>
-<ul class="simple">
-<li>adding and subtracting two matrices</li>
-<li>negation</li>
-<li>multiplication of matrices</li>
-<li>multiplying and dividing by scalar value</li>
-</ul>
-</blockquote>
-<div class="section" id="the-matrix-classes">
-<h2>The Matrix Classes<a class="headerlink" href="#the-matrix-classes" title="Permalink to this headline">¶</a></h2>
-<dl class="class">
-<dt id="ost.geom.Mat2">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Mat2</tt><a class="headerlink" href="#ost.geom.Mat2" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Mat2</tt><big>(</big><em>d00</em>, <em>d01</em>, <em>d10</em>, <em>d11</em><big>)</big></dt>
-<dd><p>2x2 real-valued matrix. The first signature creates a new identity matrix. The
-second signature initializes the matrix in row-major order.</p>
-<dl class="staticmethod">
-<dt id="ost.geom.Mat2.Identity">
-<em class="property">static </em><tt class="descname">Identity</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Mat2.Identity" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the 2x2 identity matrix</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Mat3">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Mat3</tt><a class="headerlink" href="#ost.geom.Mat3" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Mat3</tt><big>(</big><em>d00</em>, <em>d01</em>, <em>d02</em>, <em>d10</em>, <em>d11</em>, <em>d12</em>, <em>d20</em>, <em>d21</em>, <em>d22</em><big>)</big></dt>
-<dd><p>3x3 real-valued matrix. The first signature creates a new identity matrix. The
-second signature initializes the matrix in row-major order.</p>
-<dl class="staticmethod">
-<dt id="ost.geom.Mat3.Identity">
-<em class="property">static </em><tt class="descname">Identity</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Mat3.Identity" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the 3x3 identity matrix</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Mat4">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Mat4</tt><a class="headerlink" href="#ost.geom.Mat4" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Mat4</tt><big>(</big><em>d00</em>, <em>d01</em>, <em>d02</em>, <em>d03</em>, <em>d10</em>, <em>d11</em>, <em>d12</em>, <em>d13</em>, <em>d20</em>, <em>d21</em>, <em>d22</em>, <em>d23</em>, <em>d30</em>, <em>d31</em>, <em>d32</em>, <em>d33</em><big>)</big></dt>
-<dd><p>4x4 real-valued matrix. The first signature creates a new identity matrix. The
-second signature initializes the matrix in row-major order.</p>
-<dl class="method">
-<dt id="ost.geom.Mat4.ExtractRotation">
-<tt class="descname">ExtractRotation</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Mat4.ExtractRotation" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the 3x3 submatrix</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Mat4.PasteRotation">
-<tt class="descname">PasteRotation</tt><big>(</big><em>mat</em><big>)</big><a class="headerlink" href="#ost.geom.Mat4.PasteRotation" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the 3x3 submatrix of the top-left corner to <cite>mat</cite></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.geom.Mat4.ExtractTranslation">
-<tt class="descname">ExtractTranslation</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Mat4.ExtractTranslation" title="Permalink to this definition">¶</a></dt>
-<dd><p>Extract translation component from matrix. Only meaningful when matrix
-is a combination of rotation and translation matrices, otherwise the result
-is undefined.</p>
-</dd></dl>
-
-<dl class="staticmethod">
-<dt id="ost.geom.Mat4.Identity">
-<em class="property">static </em><tt class="descname">Identity</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.geom.Mat4.Identity" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the 4x4 identity matrix</p>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="functions-operating-on-matrices">
-<h2>Functions Operating on Matrices<a class="headerlink" href="#functions-operating-on-matrices" title="Permalink to this headline">¶</a></h2>
-<dl class="function">
-<dt id="ost.geom.Equal">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Equal</tt><big>(</big><em>lhs</em>, <em>rhs</em>, <em>epsilon=geom.EPSILON</em><big>)</big><a class="headerlink" href="#ost.geom.Equal" title="Permalink to this definition">¶</a></dt>
-<dd><p>Compares the two matrices <cite>lhs</cite> and <cite>rhs</cite> and returns True, if all
-of the element-wise differences are smaller than epsilon. <cite>lhs</cite>
-and <cite>rhs</cite> must be matrices of the same dimension.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>lhs</strong> (<em>Mat2Mat3Mat4</em>) – First matrix</li>
-<li><strong>rhs</strong> (<em>Mat2Mat3Mat4</em>) – Second matrix</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Transpose">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Transpose</tt><big>(</big><em>mat</em><big>)</big><a class="headerlink" href="#ost.geom.Transpose" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the transpose of <cite>mat</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>mat</strong> – The matrix to be transposed</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Invert">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Invert</tt><big>(</big><em>mat</em><big>)</big><a class="headerlink" href="#ost.geom.Invert" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the inverse of <cite>mat</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>mat</strong> (<em>Mat2Mat3Mat4</em>) – The matrix to be inverted</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<p>What happens when determinant is 0?</p>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.CompMultiply">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">CompMultiply</tt><big>(</big><em>lhs</em>, <em>rhs</em><big>)</big><a class="headerlink" href="#ost.geom.CompMultiply" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the component-wise product of <cite>lhs</cite> and <cite>rhs</cite>. <cite>lhs</cite> and
-<cite>rhs</cite> must be vectors of the same dimension.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>lhs</strong> (<em>Vec2Vec3Vec4</em>) – The lefthand-side vector</li>
-<li><strong>rhs</strong> (<em>Vec2Vec3Vec4</em>) – The righthand-side vector</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.CompDivide">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">CompDivide</tt><big>(</big><em>lhs</em>, <em>rhs</em><big>)</big><a class="headerlink" href="#ost.geom.CompDivide" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the component-wise quotient of <cite>lhs</cite> divided by <cite>rhs</cite>. <cite>lhs</cite>
-and <cite>rhs</cite> must be vectors of the same dimension.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>lhs</strong> (<em>Vec2Vec3Vec4</em>) – The lefthand-side vector</li>
-<li><strong>rhs</strong> (<em>Vec2Vec3Vec4</em>) – The righthand-side vector</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Det">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Det</tt><big>(</big><em>mat</em><big>)</big><a class="headerlink" href="#ost.geom.Det" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the determinant of <cite>mat</cite>
-:param mat: A matrix
-:type mat: <a class="reference internal" href="#ost.geom.Mat2" title="ost.geom.Mat2"><tt class="xref py py-class docutils literal"><span class="pre">Mat2</span></tt></a>, <a class="reference internal" href="#ost.geom.Mat3" title="ost.geom.Mat3"><tt class="xref py py-class docutils literal"><span class="pre">Mat3</span></tt></a> or <a class="reference internal" href="#ost.geom.Mat4" title="ost.geom.Mat4"><tt class="xref py py-class docutils literal"><span class="pre">Mat4</span></tt></a></p>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Minor">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Minor</tt><big>(</big><em>mat</em>, <em>i</em>, <em>j</em><big>)</big><a class="headerlink" href="#ost.geom.Minor" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the determinant of the 2x2 matrix generated from <cite>mat</cite> by
-removing the ith row and jth column.</p>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.EulerTransformation">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">EulerTransformation</tt><big>(</big><em>phi</em>, <em>theta</em>, <em>xi</em><big>)</big><a class="headerlink" href="#ost.geom.EulerTransformation" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a rotation matrix for the 3 euler angles <cite>phi</cite>, <cite>theta</cite>, and
-<cite>xi</cite>. The 3 angles are given in radians.</p>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.AxisRotation">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">AxisRotation</tt><big>(</big><em>axis</em>, <em>angle</em><big>)</big><a class="headerlink" href="#ost.geom.AxisRotation" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a rotation matrix that represents a rotation of <cite>angle</cite>
-around the <cite>axis</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>axis</strong> (<em>Vec3</em>) – The rotation axis. Will be normalized</li>
-<li><strong>angle</strong> – Rotation angle (radians) in clockwise direction when
-looking down the axis.</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.OrthogonalVector">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">OrthogonalVector</tt><big>(</big><em>vec</em><big>)</big><a class="headerlink" href="#ost.geom.OrthogonalVector" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get arbitrary vector orthogonal to <cite>vec</cite>. The returned vector is of length
-1, except when <cite>vec</cite> is a zero vector. In that case, the returned vector is
-(0, 0, 0).</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>vec</strong> (<em>Vec3</em>) – A vector of arbitrary length</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="composite.html" title="Geometric Objects"
- >next</a> |</li>
- <li class="right" >
- <a href="vec.html" title="Vectors"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="geom.html" ><tt class="docutils literal docutils literal docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/geom/vec.html b/doc/build/geom/vec.html
deleted file mode 100644
index 84c84d2a2363c47f7e1c2e4c9d03dc44e719783c..0000000000000000000000000000000000000000
--- a/doc/build/geom/vec.html
+++ /dev/null
@@ -1,444 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Vectors — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="up" title="geom – vectors, matrices and geometrical objects" href="geom.html" />
- <link rel="next" title="Matrices" href="mat.html" />
- <link rel="prev" title="geom – vectors, matrices and geometrical objects" href="geom.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="mat.html" title="Matrices"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="geom.html" title="geom – vectors, matrices and geometrical objects"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="geom.html" accesskey="U"><tt class="docutils literal docutils literal docutils literal docutils literal docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Vectors</a><ul>
-<li><a class="reference internal" href="#vector-classes">Vector Classes</a></li>
-<li><a class="reference internal" href="#functions-operating-on-vectors">Functions Operating on Vectors</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="geom.html"
- title="previous chapter"><tt class="docutils literal docutils literal docutils literal docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="mat.html"
- title="next chapter">Matrices</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/geom/vec.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="vectors">
-<h1>Vectors<a class="headerlink" href="#vectors" title="Permalink to this headline">¶</a></h1>
-<p>The <a class="reference internal" href="#ost.geom.Vec2" title="ost.geom.Vec2"><tt class="xref py py-class docutils literal"><span class="pre">Vec2</span></tt></a>, <a class="reference internal" href="#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a>, <a class="reference internal" href="#ost.geom.Vec4" title="ost.geom.Vec4"><tt class="xref py py-class docutils literal"><span class="pre">Vec4</span></tt></a> classes implement vectors in 2,
-3 and four dimensions. They support basic arithmetic via overloaded operators.
-Essentially, the following basic operations are available:</p>
-<blockquote>
-<ul class="simple">
-<li>adding and subtracting two vectors</li>
-<li>negation</li>
-<li>multiplying and dividing by scalar value</li>
-</ul>
-</blockquote>
-<p>This is shown in the following example:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">vec_a</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">Vec2</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">0</span><span class="p">)</span>
-<span class="n">vec_b</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">Vec2</span><span class="p">(</span><span class="mf">0</span><span class="p">,</span> <span class="mf">1</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">vec_a</span><span class="p">,</span> <span class="n">vec_b</span>
-<span class="k">print</span> <span class="n">vec_a</span><span class="o">+</span><span class="n">vec_b</span>
-<span class="k">print</span> <span class="n">vec_a</span><span class="o">*</span><span class="mf">3</span><span class="o">-</span><span class="n">vec_b</span>
-</pre></div>
-</div>
-<p>The standard vector operations are implemented as <a class="reference internal" href="#vector-functions"><em>free standing functions</em></a>:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">vec_a</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">Vec3</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">0</span><span class="p">,</span> <span class="mf">0</span><span class="p">)</span>
-<span class="n">vec_b</span><span class="o">=</span><span class="n">geom</span><span class="o">.</span><span class="n">Vec3</span><span class="p">(</span><span class="mf">0</span><span class="p">,</span> <span class="mf">1</span><span class="p">,</span> <span class="mf">0</span><span class="p">)</span>
-
-<span class="k">print</span> <span class="n">geom</span><span class="o">.</span><span class="n">Dot</span><span class="p">(</span><span class="n">vec_a</span><span class="p">,</span> <span class="n">vec_b</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">geom</span><span class="o">.</span><span class="n">Cross</span><span class="p">(</span><span class="n">vec_a</span><span class="p">,</span> <span class="n">vec_b</span><span class="p">)</span>
-
-<span class="k">print</span> <span class="n">geom</span><span class="o">.</span><span class="n">Normalize</span><span class="p">(</span><span class="n">geom</span><span class="o">.</span><span class="n">Vec3</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">1</span><span class="p">,</span> <span class="mf">0</span><span class="p">))</span>
-
-<span class="k">print</span> <span class="n">geom</span><span class="o">.</span><span class="n">Length</span><span class="p">(</span><span class="n">geom</span><span class="o">.</span><span class="n">Vec3</span><span class="p">(</span><span class="mf">1</span><span class="p">,</span> <span class="mf">1</span><span class="p">,</span> <span class="mf">1</span><span class="p">))</span>
-</pre></div>
-</div>
-<div class="section" id="vector-classes">
-<h2>Vector Classes<a class="headerlink" href="#vector-classes" title="Permalink to this headline">¶</a></h2>
-<dl class="class">
-<dt id="ost.geom.Vec2">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Vec2</tt><big>(</big><span class="optional">[</span><em>x=0.0</em>, <em>y=0.0</em>, <em>z=0.0</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.geom.Vec2" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Vec2</tt><big>(</big><em>vec</em><big>)</big></dt>
-<dd><p>Real-valued vector in 2 dimensions.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>x</strong> – x coordinate</li>
-<li><strong>y</strong> – y coordinate</li>
-<li><strong>vec</strong> – the coordinates are set to the coordinates of vec. If vec is a
-<a class="reference internal" href="#ost.geom.Vec2" title="ost.geom.Vec2"><tt class="xref py py-class docutils literal"><span class="pre">Vec2</span></tt></a>, the coordinates are copied directly, If vec is a
-<a class="reference internal" href="#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a>, the x and y coordinates are set to the
-coordinates of vec and z is silently swallowed. If vec is of
-type <a class="reference internal" href="#ost.geom.Vec4" title="ost.geom.Vec4"><tt class="xref py py-class docutils literal"><span class="pre">Vec4</span></tt></a>, x and y are divided by the homogenous
-coordinate w, raising a DivideByZeroException when w is zero.</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="attribute">
-<dt id="ost.geom.Vec2.x">
-<tt class="descname">x</tt><a class="headerlink" href="#ost.geom.Vec2.x" title="Permalink to this definition">¶</a></dt>
-<dd><p>The x-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Vec2.y">
-<tt class="descname">y</tt><a class="headerlink" href="#ost.geom.Vec2.y" title="Permalink to this definition">¶</a></dt>
-<dd><p>The y-coordinate of the vector.</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Vec3">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Vec3</tt><big>(</big><span class="optional">[</span><em>x=0.0</em>, <em>y=0.0</em>, <em>z=0.0</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.geom.Vec3" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Vec3</tt><big>(</big><em>vec</em><big>)</big></dt>
-<dd><p>Real-valued vector in 3 dimensions.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>x</strong> – x coordinate</li>
-<li><strong>y</strong> – y coordinate</li>
-<li><strong>z</strong> – z coordinate</li>
-<li><strong>vec</strong> – the coordinates are set to the coordinates of vec. If vec is a
-<a class="reference internal" href="#ost.geom.Vec3" title="ost.geom.Vec3"><tt class="xref py py-class docutils literal"><span class="pre">Vec3</span></tt></a>, the coordinates are copied directly, If vec is a
-<a class="reference internal" href="#ost.geom.Vec2" title="ost.geom.Vec2"><tt class="xref py py-class docutils literal"><span class="pre">Vec2</span></tt></a>, the x and y coordinates are set to the
-coordinates of vec and z is initialized to zero. If vec is of
-type <a class="reference internal" href="#ost.geom.Vec4" title="ost.geom.Vec4"><tt class="xref py py-class docutils literal"><span class="pre">Vec4</span></tt></a>, x, y and z are divided by homogenous
-coordinate w, raising a DivideByZeroException when w is zero.</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="attribute">
-<dt id="ost.geom.Vec3.x">
-<tt class="descname">x</tt><a class="headerlink" href="#ost.geom.Vec3.x" title="Permalink to this definition">¶</a></dt>
-<dd><p>The x-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Vec3.y">
-<tt class="descname">y</tt><a class="headerlink" href="#ost.geom.Vec3.y" title="Permalink to this definition">¶</a></dt>
-<dd><p>The y-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Vec3.z">
-<tt class="descname">z</tt><a class="headerlink" href="#ost.geom.Vec3.z" title="Permalink to this definition">¶</a></dt>
-<dd><p>The z-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.geom.Vec4">
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Vec4</tt><big>(</big><span class="optional">[</span><em>x=0.0</em>, <em>y=0.0</em>, <em>z=0.0</em>, <em>w=1.0</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.geom.Vec4" title="Permalink to this definition">¶</a></dt>
-<dt>
-<em class="property">class </em><tt class="descclassname">ost.geom.</tt><tt class="descname">Vec4</tt><big>(</big><em>vec</em><big>)</big></dt>
-<dd><p>Real-valued vector in 4 dimensions.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>x</strong> – x coordinate</li>
-<li><strong>y</strong> – y coordinate</li>
-<li><strong>z</strong> – z coordinate</li>
-<li><strong>w</strong> – w (homogenous) coordinate</li>
-<li><strong>vec</strong> – the coordinates are set to the coordinates of vec. If vec is a
-<a class="reference internal" href="#ost.geom.Vec4" title="ost.geom.Vec4"><tt class="xref py py-class docutils literal"><span class="pre">Vec4</span></tt></a>, the coordinates are copied directly, If vec is a
-<a class="reference internal" href="#ost.geom.Vec2" title="ost.geom.Vec2"><tt class="xref py py-class docutils literal"><span class="pre">Vec2</span></tt></a>, the x and y coordinates are set to the
-coordinates of vec and z and w are initialized to 0 and 1,
-respectively. If vec is of type <a class="reference internal" href="#ost.geom.Vec4" title="ost.geom.Vec4"><tt class="xref py py-class docutils literal"><span class="pre">Vec4</span></tt></a>, x, y and z are
-divided by homogenous coordinate w, raising a
-DivideByZeroException when w is zero.</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-<dl class="attribute">
-<dt id="ost.geom.Vec4.x">
-<tt class="descname">x</tt><a class="headerlink" href="#ost.geom.Vec4.x" title="Permalink to this definition">¶</a></dt>
-<dd><p>The x-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Vec4.y">
-<tt class="descname">y</tt><a class="headerlink" href="#ost.geom.Vec4.y" title="Permalink to this definition">¶</a></dt>
-<dd><p>The y-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Vec4.z">
-<tt class="descname">z</tt><a class="headerlink" href="#ost.geom.Vec4.z" title="Permalink to this definition">¶</a></dt>
-<dd><p>The z-coordinate of the vector.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.geom.Vec4.w">
-<tt class="descname">w</tt><a class="headerlink" href="#ost.geom.Vec4.w" title="Permalink to this definition">¶</a></dt>
-<dd><p>The homogenous coordinate.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Type :</th><td class="field-body">float or int</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="functions-operating-on-vectors">
-<span id="vector-functions"></span><h2>Functions Operating on Vectors<a class="headerlink" href="#functions-operating-on-vectors" title="Permalink to this headline">¶</a></h2>
-<dl class="function">
-<dt id="ost.geom.Cross">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Cross</tt><big>(</big><em>vec_a</em>, <em>vec_b</em><big>)</big><a class="headerlink" href="#ost.geom.Cross" title="Permalink to this definition">¶</a></dt>
-<dd><p>Cross product of <cite>vec_a</cite> and <cite>vec_b</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Dot">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Dot</tt><big>(</big><em>vec_a</em>, <em>vec_b</em><big>)</big><a class="headerlink" href="#ost.geom.Dot" title="Permalink to this definition">¶</a></dt>
-<dd><p>Dot (scalar) product of <cite>vec_a</cite> and <cite>vec_b</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>vec_a</strong> – first vector</li>
-<li><strong>vec_b</strong> – second vector</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Length">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Length</tt><big>(</big><em>vec</em><big>)</big><a class="headerlink" href="#ost.geom.Length" title="Permalink to this definition">¶</a></dt>
-<dd><p>Length of vector</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>vec</strong> – </li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Length2">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Length2</tt><big>(</big><em>vec</em><big>)</big><a class="headerlink" href="#ost.geom.Length2" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the squared length of <cite>vec</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>vec</strong> – </li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.geom.Normalize">
-<tt class="descclassname">ost.geom.</tt><tt class="descname">Normalize</tt><big>(</big><em>vec</em><big>)</big><a class="headerlink" href="#ost.geom.Normalize" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a normalized version of <cite>vec</cite></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>vec</strong> – Vector to be normalized</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="mat.html" title="Matrices"
- >next</a> |</li>
- <li class="right" >
- <a href="geom.html" title="geom – vectors, matrices and geometrical objects"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="geom.html" ><tt class="docutils literal docutils literal docutils literal docutils literal docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/gui/gui.html b/doc/build/gui/gui.html
deleted file mode 100644
index baad67ce638dce212bf6bda1bba6ec1e8b645b1a..0000000000000000000000000000000000000000
--- a/doc/build/gui/gui.html
+++ /dev/null
@@ -1,118 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>gui – Graphical User Interface — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="next" title="Creating a New Module" href="../newmodule.html" />
- <link rel="prev" title="io - Input and Output of Sequences, Structures and Maps" href="../io/io.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../newmodule.html" title="Creating a New Module"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../io/io.html" title="io - Input and Output of Sequences, Structures and Maps"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h4>Previous topic</h4>
- <p class="topless"><a href="../io/io.html"
- title="previous chapter"><tt class="docutils literal"><span class="pre">io</span></tt> - Input and Output of Sequences, Structures and Maps</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../newmodule.html"
- title="next chapter">Creating a New Module</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/gui/gui.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="gui-graphical-user-interface">
-<h1><tt class="xref py py-mod docutils literal"><span class="pre">gui</span></tt> – Graphical User Interface<a class="headerlink" href="#gui-graphical-user-interface" title="Permalink to this headline">¶</a></h1>
-<p>The GUI of OpenStructure is designed to be intuitive, flexible and extensible. Most of the widgets are organized in a big main window which is divided into four parts:
-the main area and three panels containing one or more smaller widgets:</p>
-<img alt="../_images/100208_OpenStructure_UI_Colored1.png" src="../_images/100208_OpenStructure_UI_Colored1.png" />
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../newmodule.html" title="Creating a New Module"
- >next</a> |</li>
- <li class="right" >
- <a href="../io/io.html" title="io - Input and Output of Sequences, Structures and Maps"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/img/alg/alg.html b/doc/build/img/alg/alg.html
deleted file mode 100644
index c24e7b9d73be7b227ae19e2898149496fba026ab..0000000000000000000000000000000000000000
--- a/doc/build/img/alg/alg.html
+++ /dev/null
@@ -1,199 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>alg - Image Processing Algorithms — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="next" title="geom – vectors, matrices and geometrical objects" href="../../geom/geom.html" />
- <link rel="prev" title="img Images and Density Maps" href="../base/img.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../../geom/geom.html" title="geom – vectors, matrices and geometrical objects"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../base/img.html" title="img Images and Density Maps"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#"><tt class="docutils literal"><span class="pre">alg</span></tt> - Image Processing Algorithms</a><ul>
-<li><a class="reference internal" href="#usage-of-image-algorithms">Usage of Image Algorithms</a></li>
-<li><a class="reference internal" href="#filters-in-fourier-space">Filters in Fourier Space</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="../base/img.html"
- title="previous chapter"><tt class="docutils literal docutils literal"><span class="pre">img</span></tt> Images and Density Maps</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../../geom/geom.html"
- title="next chapter"><tt class="docutils literal docutils literal docutils literal docutils literal docutils literal docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/img/alg/alg.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.img.alg">
-<span id="alg-image-processing-algorithms"></span><h1><a class="reference internal" href="#module-ost.img.alg" title="Image processing algorithms"><tt class="xref py py-mod docutils literal"><span class="pre">alg</span></tt></a> - Image Processing Algorithms<a class="headerlink" href="#module-ost.img.alg" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="usage-of-image-algorithms">
-<h2>Usage of Image Algorithms<a class="headerlink" href="#usage-of-image-algorithms" title="Permalink to this headline">¶</a></h2>
-<p>Image algorithms are objects. To execute them, the algorithms are applied to an
-image by passing it to the <tt class="xref py py-meth docutils literal"><span class="pre">ost.img.ImageHandle.Apply()</span></tt> or
-<tt class="xref py py-meth docutils literal"><span class="pre">ost.img.ImageHandle.ApplyIP()</span></tt> method:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">image</span><span class="o">=</span><span class="n">img</span><span class="o">.</span><span class="n">CreateImage</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Size</span><span class="p">(</span><span class="mf">200</span><span class="p">,</span> <span class="mf">200</span><span class="p">))</span>
-<span class="n">fft_image</span><span class="o">=</span><span class="n">image</span><span class="o">.</span><span class="n">Apply</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">FFT</span><span class="p">())</span>
-<span class="n">image</span><span class="o">.</span><span class="n">ApplyIP</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">FFT</span><span class="p">())</span>
-</pre></div>
-</div>
-<dl class="class">
-<dt id="ost.img.alg.FFT">
-<em class="property">class </em><tt class="descclassname">ost.img.alg.</tt><tt class="descname">FFT</tt><a class="headerlink" href="#ost.img.alg.FFT" title="Permalink to this definition">¶</a></dt>
-<dd><p>Fast Fourier Transforms the image. The FFT algorithms is aware of the
-image’s domain. The following rules apply:</p>
-<blockquote>
-<ul class="simple">
-<li>SPATIAL -> HALF_FREQUENCY</li>
-<li>HALF_FREQUENCY -> SPATIAL</li>
-<li>FREQUENCY -> COMPLEX_SPATIAL</li>
-<li>COMPLEX_SPATIAL -> FREQUENCY</li>
-</ul>
-</blockquote>
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.img.alg.GaussianFilter">
-<em class="property">class </em><tt class="descclassname">ost.img.alg.</tt><tt class="descname">GaussianFilter</tt><big>(</big><em>sigma=1.0</em><big>)</big><a class="headerlink" href="#ost.img.alg.GaussianFilter" title="Permalink to this definition">¶</a></dt>
-<dd><p>Applies a gaussian filter to the supplied image. Sigma is given in pixels.</p>
-<p>Implemented after I.T.Young, L.J. van Vliet,”Recursive implementation of the
-Gaussian filter”, Signal Processing, 44(1995), 139-151</p>
-</dd></dl>
-
-</div>
-<div class="section" id="filters-in-fourier-space">
-<h2>Filters in Fourier Space<a class="headerlink" href="#filters-in-fourier-space" title="Permalink to this headline">¶</a></h2>
-<p>The following filters operate in Fourier Space. If the image they are applied on is in spatial domain, they will first be converted to frequency domain and then converted back after the filter has been applied.</p>
-<dl class="class">
-<dt id="ost.img.alg.LowpassFilter">
-<em class="property">class </em><tt class="descclassname">ost.img.alg.</tt><tt class="descname">LowpassFilter</tt><big>(</big><em>freq_limit</em><big>)</big><a class="headerlink" href="#ost.img.alg.LowpassFilter" title="Permalink to this definition">¶</a></dt>
-<dd><p>Filters an image by masking out frequencies higher than
-<cite>freg_limit</cite>.</p>
-<dl class="method">
-<dt id="ost.img.alg.LowpassFilter.GetLimit">
-<tt class="descname">GetLimit</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.img.alg.LowpassFilter.GetLimit" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the frequency limit</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.img.alg.LowpassFilter.SetLimit">
-<tt class="descname">SetLimit</tt><big>(</big><em>freq</em><big>)</big><a class="headerlink" href="#ost.img.alg.LowpassFilter.SetLimit" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the frequency limit</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.img.alg.HighpassFilter">
-<em class="property">class </em><tt class="descclassname">ost.img.alg.</tt><tt class="descname">HighpassFilter</tt><a class="headerlink" href="#ost.img.alg.HighpassFilter" title="Permalink to this definition">¶</a></dt>
-<dd><p>Filters an image by masking out frequences lower than <cite>freq_limit</cite></p>
-<dl class="method">
-<dt id="ost.img.alg.HighpassFilter.GetLimit">
-<tt class="descname">GetLimit</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.img.alg.HighpassFilter.GetLimit" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the frequency limit</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.img.alg.HighpassFilter.SetLimit">
-<tt class="descname">SetLimit</tt><big>(</big><em>freq</em><big>)</big><a class="headerlink" href="#ost.img.alg.HighpassFilter.SetLimit" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the frequency limit</p>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../../geom/geom.html" title="geom – vectors, matrices and geometrical objects"
- >next</a> |</li>
- <li class="right" >
- <a href="../base/img.html" title="img Images and Density Maps"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/img/base/img.html b/doc/build/img/base/img.html
deleted file mode 100644
index f87f5449b035701ee74d2c959382238351f3d81c..0000000000000000000000000000000000000000
--- a/doc/build/img/base/img.html
+++ /dev/null
@@ -1,291 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>img Images and Density Maps — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="next" title="alg - Image Processing Algorithms" href="../alg/alg.html" />
- <link rel="prev" title="Storing Custom Data" href="../../base/generic.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../alg/alg.html" title="alg - Image Processing Algorithms"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../../base/generic.html" title="Storing Custom Data"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#"><tt class="docutils literal"><span class="pre">img</span></tt> Images and Density Maps</a><ul>
-<li><a class="reference internal" href="#introduction-the-imagehandle">Introduction : The ImageHandle</a></li>
-<li><a class="reference internal" href="#creating-and-visualizing-imagehandles">Creating and visualizing ImageHandles</a></li>
-<li><a class="reference internal" href="#reading-and-writing-into-an-image">Reading and writing into an image</a></li>
-<li><a class="reference internal" href="#applying-a-fourier-transform">Applying a Fourier Transform</a></li>
-<li><a class="reference internal" href="#extracting-and-pasting-images">Extracting and Pasting Images</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="../../base/generic.html"
- title="previous chapter">Storing Custom Data</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../alg/alg.html"
- title="next chapter"><tt class="docutils literal docutils literal docutils literal"><span class="pre">alg</span></tt> - Image Processing Algorithms</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/img/base/img.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.img">
-<span id="img-images-and-density-maps"></span><h1><a class="reference internal" href="#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> Images and Density Maps<a class="headerlink" href="#module-ost.img" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="introduction-the-imagehandle">
-<h2>Introduction : The ImageHandle<a class="headerlink" href="#introduction-the-imagehandle" title="Permalink to this headline">¶</a></h2>
-<p>OpenStructure offers extensive processing capabilities for planar 2d images and
-3d maps using the img module. Images are manipulated through the use of
-dox[ost::img::ImageHandle|ImageHandles].</p>
-<p>ImageHandles provide a clean and efficient interface to interact with images and
-maps. An <tt class="xref py py-class docutils literal"><span class="pre">ImageHandle</span></tt> can store an image in either real (‘SPATIAL’) or
-Fourier (‘FREQUENCY’) space and always keep track of the currently active
-domain. This means,for example that one can apply a Fourier Transformation to an
-ImageHandle containing a ‘SPATIAL’ image and the ImageHandle will correctly
-identify the new active domain as ‘FREQUENCY’. The ImageHandle also understands,
-for example, that applying a Fourier Transform to a centrosymmetric ‘FREQUENCY’
-image results in a real ‘SPATIAL’ image, but applying it to a
-non-centrosymmetric one results in a complex ‘SPATIAL’ image.</p>
-<p>Furthermore, the ImageHandle will make sure that real and Fourier space
-information about the image are always in sync. If, for example, the pixel
-sampling is changed while the current active domain is real space, the pixel
-sampling in Fourier space will be adjusted accordingly, and vice versa.</p>
-<p>Moreover, the ImageHandle allows the extraction of both complex and real numeric
-values from images in any active domain. If the domain is complex in nature, but
-a real numeric value is requested, the amplitude of the complex number will be
-returned. If the numerical nature of the domain is real and a complex number is
-requested, the complex part will be set to 0.</p>
-</div>
-<div class="section" id="creating-and-visualizing-imagehandles">
-<h2>Creating and visualizing ImageHandles<a class="headerlink" href="#creating-and-visualizing-imagehandles" title="Permalink to this headline">¶</a></h2>
-<p>As a first step, enter the following lines in the OpenStructure python console:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">im</span><span class="o">=</span><span class="n">img</span><span class="o">.</span><span class="n">CreateImage</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Size</span><span class="p">(</span><span class="mf">200</span><span class="p">,</span><span class="mf">200</span><span class="p">))</span>
-</pre></div>
-</div>
-</blockquote>
-<p>This will create an empty, 2D image, with a height and width of 200 pixels, whose
-origin (ie the pixel with the coordinates <0,0>) is in the top-left corner.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">v</span><span class="o">=</span><span class="n">gui</span><span class="o">.</span><span class="n">CreateDataViewer</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>A viewer window will pop up (see below), showing a white frame on a black background.
-The inner area of the white frame is the image, which is empty.</p>
-</div>
-<div class="section" id="reading-and-writing-into-an-image">
-<h2>Reading and writing into an image<a class="headerlink" href="#reading-and-writing-into-an-image" title="Permalink to this headline">¶</a></h2>
-<p>Data can be read and written from and into an image using the following commands:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># writes the real value 23.4 into pixel 10,10</span>
-<span class="n">im</span><span class="o">.</span><span class="n">SetReal</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Point</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span><span class="mf">10</span><span class="p">),</span><span class="mf">23.4</span><span class="p">)</span>
-<span class="c"># reads the value in pixel 10,10</span>
-<span class="n">val</span><span class="o">=</span><span class="n">im</span><span class="o">.</span><span class="n">GetReal</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Point</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span><span class="mf">10</span><span class="p">))</span>
-</pre></div>
-</div>
-</blockquote>
-<p>The complex equivalents are also available</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># writes the complex value value 2+3j into pixel 10,10</span>
-<span class="n">im</span><span class="o">.</span><span class="n">SetComplex</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Point</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span><span class="mf">10</span><span class="p">),</span><span class="mf">2</span><span class="o">+</span><span class="mf">3</span><span class="n">j</span><span class="p">)</span>
-<span class="c"># reads the value in pixel 10,10</span>
-<span class="n">val</span><span class="o">=</span><span class="n">im</span><span class="o">.</span><span class="n">GetComplex</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Point</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span><span class="mf">10</span><span class="p">))</span>
-</pre></div>
-</div>
-</blockquote>
-<p>The image knows in which domain it is, and will adjust the type of data being written
-accordingly. For example, if one writes a complex value in a ‘SPATIAL’ image, the value
-will be automatically converted to a real one by taking the amplitude of the complex number
-On the other hand, if one writes a real value in a ‘FREQUENCY’ image, the value is automatically
-converted to complex by setting the imaginary part to 0.</p>
-<p>## Applying algorithms</p>
-<p>Let us fill the image with random values.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">rand_alg</span> <span class="o">=</span> <span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">Randomize</span><span class="p">()</span> <span class="c"># create algorithm object</span>
-<span class="n">im</span><span class="o">.</span><span class="n">ApplyIP</span><span class="p">(</span> <span class="n">rand_alg</span> <span class="p">)</span> <span class="c"># apply algorithm object in-place</span>
-</pre></div>
-</div>
-</blockquote>
-<p>As you can see, applying an algorithm is conceptually a two-step process. First,
-an instance of an algorithm class is created, yielding an algorithm object (in
-this case ‘rand_alg’). In a second step, the algorithm object is applied to an
-image, either in-place, modifying the image, or out-of-place, leaving the
-original image untouched, and returning the result as a new image. Note that the
-in-place/out-of-place logic is decoupled from the algorithm object.</p>
-<p>Now that we have some (noisy) data present, let us run another algorithm, this
-time a Gaussian filter with a sigma of 4 pixel.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">im</span><span class="o">.</span><span class="n">ApplyIP</span><span class="p">(</span> <span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">GaussianFilter</span><span class="p">(</span><span class="mf">4.0</span><span class="p">)</span> <span class="p">)</span> <span class="c"># apply temporary algorithm object in-place</span>
-</pre></div>
-</div>
-</blockquote>
-<p>As you can see, it is not always necessary to create an independent algorithm
-instance first, in many cases a temporary object will suffice (this applies to
-the randomization algorithm as well, ‘im.ApplyIP(alg.Randomize())’ would have
-been fine). However, when used this way, the algorithm class will cease to exist
-as soon as the algorithm is applied. This can be important if the algorithm
-stores some values that need to be recovered later. For example:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">stat</span><span class="o">=</span><span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">Stat</span><span class="p">()</span>
-<span class="n">im</span><span class="o">.</span><span class="n">ApplyIP</span><span class="p">(</span><span class="n">stat</span><span class="p">)</span>
-<span class="n">mean</span><span class="o">=</span><span class="n">stat</span><span class="o">.</span><span class="n">GetMean</span><span class="p">()</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Algorithms are stateful objects and can store values. The ‘Stat’ algorithm
-computes basic statistics about the image it is applied on (maximum and minimum
-values, standard deviations, etc). The data are stored within the algorithm
-instance and can be recovered using the algorithm’s methods. It would obviously
-make very little sense not to create an instance of the ‘Stat’ algorithm. When
-the algorithms ceases to exist, all information would be lost.</p>
-</div>
-<div class="section" id="applying-a-fourier-transform">
-<h2>Applying a Fourier Transform<a class="headerlink" href="#applying-a-fourier-transform" title="Permalink to this headline">¶</a></h2>
-<p>An image is Fourier-transformed using the ‘img.alg.FFT()’ algorithm object:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">im</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadImage</span><span class="p">(</span><span class="s">"imagename.tif"</span><span class="p">)</span> <span class="c"># load the image</span>
-<span class="c"># create an instance of the fft algorithm object</span>
-<span class="n">fft</span><span class="o">=</span><span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">FFT</span><span class="p">()</span>
-<span class="c"># do the actual Fourier transformation</span>
-<span class="n">im_ft</span><span class="o">=</span><span class="n">im</span><span class="o">.</span><span class="n">Apply</span><span class="p">(</span><span class="n">fft</span><span class="p">)</span>
-<span class="c"># back-transform</span>
-<span class="n">im2</span> <span class="o">=</span> <span class="n">im_ft</span><span class="o">.</span><span class="n">Apply</span><span class="p">(</span><span class="n">fft</span><span class="p">)</span>
-<span class="c"># if this is run from within the dng graphical frontend, open viewers to</span>
-<span class="c"># look at the images</span>
-<span class="n">gui</span><span class="o">.</span><span class="n">CreateDataViewer</span><span class="p">(</span><span class="n">im</span><span class="p">)</span>
-<span class="n">gui</span><span class="o">.</span><span class="n">CreateDataViewer</span><span class="p">(</span><span class="n">im_ft</span><span class="p">)</span>
-<span class="n">gui</span><span class="o">.</span><span class="n">CreateDataViewer</span><span class="p">(</span><span class="n">im2</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>It is not really necessary to use the ‘fft’ variable to store the ‘im.alg.FFT()’
-instance, a temporary object can be used, since the ‘FFT’ algorithm object is stateless. In addition, the algorithm can be applied in-place to avoid the
-creation of a second image:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">im</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadImage</span><span class="p">(</span><span class="s">"imagename.tif"</span><span class="p">)</span> <span class="c"># load the image</span>
-<span class="c"># do the actual Fourier transformation, in-place using temporary object</span>
-<span class="n">im</span><span class="o">.</span><span class="n">ApplyIP</span><span class="p">(</span><span class="n">alg</span><span class="o">.</span><span class="n">FFT</span><span class="p">())</span>
-<span class="c"># repeating this command will do the back-transform</span>
-<span class="n">im</span><span class="o">.</span><span class="n">ApplyIP</span><span class="p">(</span><span class="n">alg</span><span class="o">.</span><span class="n">FFT</span><span class="p">())</span>
-</pre></div>
-</div>
-</blockquote>
-<p>As said before, the ‘alg.FFT()’ algorithm does not require a direction to be given, this is implicitly
-determined by the active domain of the underlying image state: a ‘SPATIAL’ image will always be
-transformed to the ‘FREQUENCY’ domain, and vice-versa.</p>
-</div>
-<div class="section" id="extracting-and-pasting-images">
-<h2>Extracting and Pasting Images<a class="headerlink" href="#extracting-and-pasting-images" title="Permalink to this headline">¶</a></h2>
-<p>An image can be extracted and pasted into another image using the ‘Extract()’
-and ‘Paste()’ member functions:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># load the image</span>
-<span class="n">im</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadImage</span><span class="p">(</span><span class="s">"imagename.tif"</span><span class="p">)</span>
-<span class="c"># generate a subimage from the region going from (10,10) to (30,30)</span>
-<span class="n">im2</span><span class="o">=</span><span class="n">im</span><span class="o">.</span><span class="n">Extract</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Extent</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">Point</span><span class="p">(</span><span class="mf">10</span><span class="p">,</span><span class="mf">10</span><span class="p">),</span><span class="n">img</span><span class="o">.</span><span class="n">Point</span><span class="p">(</span><span class="mf">30</span><span class="p">,</span><span class="mf">30</span><span class="p">)))</span>
-<span class="c"># generate an empty image with the same size as the original image</span>
-<span class="n">im3</span><span class="o">=</span><span class="n">img</span><span class="o">.</span><span class="n">CreateImage</span><span class="p">(</span><span class="n">im</span><span class="o">.</span><span class="n">GetExtent</span><span class="p">())</span>
-<span class="c"># paste the subimage into the empty image</span>
-<span class="n">im3</span><span class="o">.</span><span class="n">Paste</span><span class="p">(</span><span class="n">im2</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Note that the extent is fully honored for the paste operation, i.e. only the
-region where the pasted-to and the pasted-in image overlap will be affected.</p>
-<blockquote>
-</blockquote>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../alg/alg.html" title="alg - Image Processing Algorithms"
- >next</a> |</li>
- <li class="right" >
- <a href="../../base/generic.html" title="Storing Custom Data"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/index.html b/doc/build/index.html
deleted file mode 100644
index 45ae1e5e0ff720811ae7bbdaa49ffcc39c0a9894..0000000000000000000000000000000000000000
--- a/doc/build/index.html
+++ /dev/null
@@ -1,235 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>OpenStructure documentation — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="#" />
- <link rel="next" title="A gentle introduction to OpenStructure" href="intro.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="intro.html" title="A gentle introduction to OpenStructure"
- accesskey="N">next</a> |</li>
- <li><a href="#">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="#">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">OpenStructure documentation</a><ul>
-<li><a class="reference internal" href="#introduction">Introduction</a><ul>
-</ul>
-</li>
-<li><a class="reference internal" href="#modules">Modules</a><ul>
-</ul>
-</li>
-<li><a class="reference internal" href="#extending-openstructure">Extending OpenStructure</a><ul>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
- <h4>Next topic</h4>
- <p class="topless"><a href="intro.html"
- title="next chapter">A gentle introduction to OpenStructure</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="_sources/index.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="openstructure-documentation">
-<h1>OpenStructure documentation<a class="headerlink" href="#openstructure-documentation" title="Permalink to this headline">¶</a></h1>
-<div class="toctree-wrapper compound">
-<ul class="simple">
-</ul>
-</div>
-<div class="section" id="introduction">
-<h2>Introduction<a class="headerlink" href="#introduction" title="Permalink to this headline">¶</a></h2>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="intro.html">A gentle introduction to OpenStructure</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#what-will-be-covered-in-this-tutorial">What will be covered in this tutorial?</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#getting-ready-to-rumble">Getting ready to rumble</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#loading-and-inspecting-a-protein-structure">Loading and inspecting a protein structure</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#let-there-be-shiny-graphics">Let There Be Shiny Graphics</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#introduction-to-views">Introduction to Views</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#the-query-language">The Query Language</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#constructing-views-manually">Constructing Views Manually</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#saving-an-entity">Saving an Entity</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#loading-images-and-density-maps">Loading images and density maps</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#manipulating-images-and-density-maps">Manipulating images and density maps</a></li>
-<li class="toctree-l2"><a class="reference internal" href="intro.html#displaying-images-and-density-maps">Displaying images and density maps</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="install.html">Installing OpenStructure</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="install.html#installing-the-dependencies">Installing the Dependencies</a></li>
-<li class="toctree-l2"><a class="reference internal" href="install.html#checking-out-the-source">Checking out the Source</a></li>
-<li class="toctree-l2"><a class="reference internal" href="install.html#configuring">Configuring</a></li>
-<li class="toctree-l2"><a class="reference internal" href="install.html#building-the-project">Building the Project</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-<div class="section" id="modules">
-<h2>Modules<a class="headerlink" href="#modules" title="Permalink to this headline">¶</a></h2>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="base/generic.html">Storing Custom Data</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="base/generic.html#introduction">Introduction</a></li>
-<li class="toctree-l2"><a class="reference internal" href="base/generic.html#storing-and-accessing-data">Storing and Accessing Data</a></li>
-<li class="toctree-l2"><a class="reference internal" href="base/generic.html#use-of-generic-properties-in-queries">Use of Generic Properties in Queries</a></li>
-<li class="toctree-l2"><a class="reference internal" href="base/generic.html#api-documentation">API documentation</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="img/base/img.html"><tt class="docutils literal"><span class="pre">img</span></tt> Images and Density Maps</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="img/base/img.html#introduction-the-imagehandle">Introduction : The ImageHandle</a></li>
-<li class="toctree-l2"><a class="reference internal" href="img/base/img.html#creating-and-visualizing-imagehandles">Creating and visualizing ImageHandles</a></li>
-<li class="toctree-l2"><a class="reference internal" href="img/base/img.html#reading-and-writing-into-an-image">Reading and writing into an image</a></li>
-<li class="toctree-l2"><a class="reference internal" href="img/base/img.html#applying-a-fourier-transform">Applying a Fourier Transform</a></li>
-<li class="toctree-l2"><a class="reference internal" href="img/base/img.html#extracting-and-pasting-images">Extracting and Pasting Images</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="img/alg/alg.html"><tt class="docutils literal"><span class="pre">alg</span></tt> - Image Processing Algorithms</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="img/alg/alg.html#usage-of-image-algorithms">Usage of Image Algorithms</a></li>
-<li class="toctree-l2"><a class="reference internal" href="img/alg/alg.html#filters-in-fourier-space">Filters in Fourier Space</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="geom/geom.html"><tt class="docutils literal"><span class="pre">geom</span></tt> – vectors, matrices and geometrical objects</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="geom/vec.html">Vectors</a></li>
-<li class="toctree-l2"><a class="reference internal" href="geom/mat.html">Matrices</a></li>
-<li class="toctree-l2"><a class="reference internal" href="geom/composite.html">Geometric Objects</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="conop/conop.html"><tt class="docutils literal"><span class="pre">conop</span></tt> – Connectivity and Topology of Molecules</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="conop/conop.html#motivation">Motivation</a></li>
-<li class="toctree-l2"><a class="reference internal" href="conop/conop.html#the-builder-interface">The Builder interface</a></li>
-<li class="toctree-l2"><a class="reference internal" href="conop/conop.html#connecting-atoms">Connecting atoms</a></li>
-<li class="toctree-l2"><a class="reference internal" href="conop/conop.html#convert-mm-cif-dictionary">Convert MM CIF dictionary</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="mol/base/mol.html"><tt class="docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="mol/base/entity.html">The Molecular Entity</a></li>
-<li class="toctree-l2"><a class="reference internal" href="mol/base/editors.html">Editors</a></li>
-<li class="toctree-l2"><a class="reference internal" href="mol/base/query.html">Queries</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="seq/base/seq.html"><tt class="docutils literal"><span class="pre">seq</span></tt> – Sequences and Alignments</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="seq/base/seq.html#attaching-structures-to-sequences">Attaching Structures to Sequences</a></li>
-<li class="toctree-l2"><a class="reference internal" href="seq/base/seq.html#loading-and-saving-sequences-and-alignments">Loading and Saving Sequences and Alignments</a></li>
-<li class="toctree-l2"><a class="reference internal" href="seq/base/seq.html#the-sequencehandle">The SequenceHandle</a></li>
-<li class="toctree-l2"><a class="reference internal" href="seq/base/seq.html#the-sequencelist">The SequenceList</a></li>
-<li class="toctree-l2"><a class="reference internal" href="seq/base/seq.html#the-alignmenthandle">The AlignmentHandle</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="base/base.html"><tt class="docutils literal"><span class="pre">ost.settings</span></tt> - Locate Files and Retrieve Preferences</a></li>
-<li class="toctree-l1"><a class="reference internal" href="io/io.html"><tt class="docutils literal"><span class="pre">io</span></tt> - Input and Output of Sequences, Structures and Maps</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="io/io.html#molecular-structures">Molecular Structures</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="gui/gui.html"><tt class="docutils literal"><span class="pre">gui</span></tt> – Graphical User Interface</a></li>
-</ul>
-</div>
-</div>
-<div class="section" id="extending-openstructure">
-<h2>Extending OpenStructure<a class="headerlink" href="#extending-openstructure" title="Permalink to this headline">¶</a></h2>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="newmodule.html">Creating a New Module</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="newmodule.html#directory-structure">Directory Structure</a></li>
-<li class="toctree-l2"><a class="reference internal" href="newmodule.html#the-module-code">The Module Code</a></li>
-<li class="toctree-l2"><a class="reference internal" href="newmodule.html#the-testing-framework">The Testing Framework</a></li>
-<li class="toctree-l2"><a class="reference internal" href="newmodule.html#the-python-wrapper">The Python Wrapper</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="external.html">Using External Programs within OpenStructure</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="external.html#introduction">Introduction</a></li>
-<li class="toctree-l2"><a class="reference internal" href="external.html#locating-the-executable">Locating the Executable</a></li>
-<li class="toctree-l2"><a class="reference internal" href="external.html#prepare-all-files">Prepare All Files</a></li>
-<li class="toctree-l2"><a class="reference internal" href="external.html#execute-the-external-program">Execute the External Program</a></li>
-<li class="toctree-l2"><a class="reference internal" href="external.html#read-generated-output">Read Generated Output</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="intro.html" title="A gentle introduction to OpenStructure"
- >next</a> |</li>
- <li><a href="#">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/install.html b/doc/build/install.html
deleted file mode 100644
index 9b5851f7a3870960b464cb57521268a90adc0623..0000000000000000000000000000000000000000
--- a/doc/build/install.html
+++ /dev/null
@@ -1,227 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Installing OpenStructure — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
- <link rel="next" title="Storing Custom Data" href="base/generic.html" />
- <link rel="prev" title="A gentle introduction to OpenStructure" href="intro.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="base/generic.html" title="Storing Custom Data"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="intro.html" title="A gentle introduction to OpenStructure"
- accesskey="P">previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Installing OpenStructure</a><ul>
-<li><a class="reference internal" href="#installing-the-dependencies">Installing the Dependencies</a></li>
-<li><a class="reference internal" href="#checking-out-the-source">Checking out the Source</a></li>
-<li><a class="reference internal" href="#configuring">Configuring</a><ul>
-<li><a class="reference internal" href="#flag-to-choose-build-system">Flag to choose build system</a></li>
-<li><a class="reference internal" href="#flags-to-control-the-dependencies">Flags to Control the Dependencies</a></li>
-<li><a class="reference internal" href="#build-options">Build Options</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#building-the-project">Building the Project</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="intro.html"
- title="previous chapter">A gentle introduction to OpenStructure</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="base/generic.html"
- title="next chapter">Storing Custom Data</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="_sources/install.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="installing-openstructure">
-<h1>Installing OpenStructure<a class="headerlink" href="#installing-openstructure" title="Permalink to this headline">¶</a></h1>
-<p>This document describes how to install OpenStructure from source. If you are not planning to develop code for OpenStructure, you might be better off with one of the binaries available for download.</p>
-<div class="section" id="installing-the-dependencies">
-<h2>Installing the Dependencies<a class="headerlink" href="#installing-the-dependencies" title="Permalink to this headline">¶</a></h2>
-<p>OpenStructure uses a bunch of OpenSource libraries. If you haven’t already installed them, please install them now!</p>
-<blockquote>
-<ul class="simple">
-<li><a class="reference external" href="http://cmake.org">CMake</a></li>
-<li><a class="reference external" href="http://eigen.tuxfamily.org">Eigen2</a></li>
-<li><a class="reference external" href="http://boost.org">Boost</a></li>
-<li><a class="reference external" href="http://www.libpng.org">libpng</a></li>
-<li><a class="reference external" href="http://python.org">Python</a></li>
-<li><a class="reference external" href="http://qt.nokia.com">Qt</a></li>
-</ul>
-</blockquote>
-<p>When you enable support for image processing, you will need:</p>
-<blockquote>
-<ul class="simple">
-<li><a class="reference external" href="http://fftw.org">FFTW3</a>. By default, OpenStructure is compiled with single precision and thus also requires FFTW to be compiled with single precision. Most platforms offer this as a second package. If you are compiling manually, use the <cite>–enable-single</cite> option.</li>
-<li><a class="reference external" href="http://www.libtiff.org">libtiff</a></li>
-</ul>
-</blockquote>
-<p>If you would like to use the graphical user interface, also install:</p>
-<blockquote>
-<ul class="simple">
-<li><a class="reference external" href="http://www.riverbankcomputing.co.uk/software/sip/download">SIP</a>.</li>
-<li><a class="reference external" href="http://www.riverbankcomputing.co.uk/software/pyqt/download">PyQt4</a>.</li>
-</ul>
-</blockquote>
-<p>In case you are compiling under Windows you have to install <a class="reference external" href="http://www.microsoft.com/express/Downloads">Visualstudio
-2008</a>. to compile the dependecies
-and OpenStructure. We recommend to compile the dependecies manually. Enter the
-directories where the dependencies are located in Tools->Options->Projects and
-Solutions->VC++ directories. Choose ‘bin’ directories to enter program paths to
-cmake, qmake and python, ‘lib’ directories to point to the location(s) of your
-dependencies.</p>
-</div>
-<div class="section" id="checking-out-the-source">
-<h2>Checking out the Source<a class="headerlink" href="#checking-out-the-source" title="Permalink to this headline">¶</a></h2>
-<p>You can checkout the source from SVN. The repository is located at</p>
-<blockquote>
-<a class="reference external" href="https://dng.biozentrum.unibas.ch/svn/openstructure/trunk">https://dng.biozentrum.unibas.ch/svn/openstructure/trunk</a></blockquote>
-<p>If you are using the commandline client, type in your shell</p>
-<blockquote>
-svn co <a class="reference external" href="https://ost.biozentrum.unibas.ch/svn/openstructure/trunk">https://ost.biozentrum.unibas.ch/svn/openstructure/trunk</a></blockquote>
-<p>On Windows install svn clients like <a class="reference external" href="http://tortoisesvn.tigris.org">tortoisesvn</a> and use the function ‘checkout’ then enter the above mention URL.</p>
-</div>
-<div class="section" id="configuring">
-<h2>Configuring<a class="headerlink" href="#configuring" title="Permalink to this headline">¶</a></h2>
-<p>OpenStructure uses <a class="reference external" href="http://cmake.org">CMake</a> for compiling and building the project. The next required step is to configure the build environment using cmake. You can do that by invoking <cite>cmake</cite> in the project directory (On Windows choose Tools->visualstudio commandline prompt from within visualstudio) :</p>
-<blockquote>
-cmake . <options></blockquote>
-<p>There are two kinds of options: Options that let you control the building behaviour, enabling and disabling the compilation of certain modules and options that let you tell CMake where to find the dependencies. All of them are passed to CMake with via <cite>-D<opt>=<value></cite>.</p>
-<div class="section" id="flag-to-choose-build-system">
-<h3>Flag to choose build system<a class="headerlink" href="#flag-to-choose-build-system" title="Permalink to this headline">¶</a></h3>
-<p>On Windows make sure you specify -G”Visual Studio 9 2008”!</p>
-</div>
-<div class="section" id="flags-to-control-the-dependencies">
-<h3>Flags to Control the Dependencies<a class="headerlink" href="#flags-to-control-the-dependencies" title="Permalink to this headline">¶</a></h3>
-<p>By default, <a class="reference external" href="http://cmake.org">CMake</a> searches the standard directories for dependencies. However, on some systems, this might not be enough. Here is a short description of how CMake figures out what dependencies to take and how you can influence it.</p>
-<blockquote>
-<ul class="simple">
-<li>Boost is mainly controlled via the <cite>BOOST_ROOT</cite> option. If boost wasn’t
-found, it should be set to the prefix of the boost installation.</li>
-<li><cite>QT_QMAKE_EXECUTABLE</cite> defines the exact Qt installation to take. It should
-be set to the full path to <cite>qmake</cite>.</li>
-<li><cite>PYTHON_ROOT</cite> is the Python equivalent of BOOST_ROOT. It should be set to
-the prefix path containing the python binary, headers and libraries.</li>
-<li><cite>SYS_ROOT</cite> controls the general prefix for searching libraries and headers.
-By default, it is set to <cite>/</cite>.</li>
-</ul>
-</blockquote>
-</div>
-<div class="section" id="build-options">
-<h3>Build Options<a class="headerlink" href="#build-options" title="Permalink to this headline">¶</a></h3>
-<blockquote>
-<ul class="simple">
-<li><cite>ENABLE_UI</cite> controls whether to build the graphical user interface module. By
-default it is set to true.</li>
-<li><cite>ENABLE_IMG</cite> controls whether to build the image processing module. This will
-enable support for density maps, and general image processing in 1, 2 an 3
-dimensions. By default it is set to true.</li>
-<li><cite>ENABLE_GFX</cite> controls whether to build the graphics module. By default, this
-is set to true. If set to none, this implies <cite>ENABLE_UI=NO</cite>.</li>
-<li>Shader support is controlled with <cite>USE_SHADER</cite>. By default, no shaders are
-used.</li>
-<li>If <cite>OPTIMIZE</cite> is set to 1, an optimized version of OpenStructure is built.</li>
-</ul>
-</blockquote>
-</div>
-</div>
-<div class="section" id="building-the-project">
-<h2>Building the Project<a class="headerlink" href="#building-the-project" title="Permalink to this headline">¶</a></h2>
-<p>Type <cite>make</cite>. If you are using a multi-core machine, you can use the <cite>-j</cite> flag to run
-multiple jobs at once.</p>
-<p>On Windows run ‘Build OpenStructure’ from the build menu.</p>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="base/generic.html" title="Storing Custom Data"
- >next</a> |</li>
- <li class="right" >
- <a href="intro.html" title="A gentle introduction to OpenStructure"
- >previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/intro.html b/doc/build/intro.html
deleted file mode 100644
index e8bc4cfcd3c3948c11f4d16c06d0138d3ff92728..0000000000000000000000000000000000000000
--- a/doc/build/intro.html
+++ /dev/null
@@ -1,479 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>A gentle introduction to OpenStructure — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
- <link rel="next" title="Installing OpenStructure" href="install.html" />
- <link rel="prev" title="OpenStructure documentation" href="index.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="install.html" title="Installing OpenStructure"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="index.html" title="OpenStructure documentation"
- accesskey="P">previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">A gentle introduction to OpenStructure</a><ul>
-<li><a class="reference internal" href="#what-will-be-covered-in-this-tutorial">What will be covered in this tutorial?</a></li>
-<li><a class="reference internal" href="#getting-ready-to-rumble">Getting ready to rumble</a><ul>
-<li><a class="reference internal" href="#starting-dng">Starting DNG</a></li>
-<li><a class="reference internal" href="#interactive-python-shell">Interactive Python Shell</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#loading-and-inspecting-a-protein-structure">Loading and inspecting a protein structure</a></li>
-<li><a class="reference internal" href="#let-there-be-shiny-graphics">Let There Be Shiny Graphics</a></li>
-<li><a class="reference internal" href="#introduction-to-views">Introduction to Views</a></li>
-<li><a class="reference internal" href="#the-query-language">The Query Language</a></li>
-<li><a class="reference internal" href="#constructing-views-manually">Constructing Views Manually</a></li>
-<li><a class="reference internal" href="#saving-an-entity">Saving an Entity</a></li>
-<li><a class="reference internal" href="#loading-images-and-density-maps">Loading images and density maps</a></li>
-<li><a class="reference internal" href="#manipulating-images-and-density-maps">Manipulating images and density maps</a></li>
-<li><a class="reference internal" href="#displaying-images-and-density-maps">Displaying images and density maps</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="index.html"
- title="previous chapter">OpenStructure documentation</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="install.html"
- title="next chapter">Installing OpenStructure</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="_sources/intro.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="a-gentle-introduction-to-openstructure">
-<h1>A gentle introduction to OpenStructure<a class="headerlink" href="#a-gentle-introduction-to-openstructure" title="Permalink to this headline">¶</a></h1>
-<p>In this tutorial you will be learning by example how to use the OpenStructure
-framework.</p>
-<p>We assume that you already have a version of OpenStructure installed. If not,
-please refer to <a class="reference internal" href="install.html"><em>Installing OpenStructure</em></a>.</p>
-<div class="section" id="what-will-be-covered-in-this-tutorial">
-<h2>What will be covered in this tutorial?<a class="headerlink" href="#what-will-be-covered-in-this-tutorial" title="Permalink to this headline">¶</a></h2>
-<p>This tutorial is aimed at users that would like to get their hands dirty and
-execute commands in Python and write scripts rather clicking their way through a
-shiny user interface. The user interface of OpenStructure is in a very early
-state anyway that you probably won’t go far by clicking you way through...</p>
-<p>The first part of the tutorial is a walk-through of the basic functionality you
-will be using in your everyday work. You will learn how to load structure
-datasets, inspect, display them in the 3D window and save them.</p>
-</div>
-<div class="section" id="getting-ready-to-rumble">
-<h2>Getting ready to rumble<a class="headerlink" href="#getting-ready-to-rumble" title="Permalink to this headline">¶</a></h2>
-<p>The files we will be using in the tutorial are available in the examples folder
-that comes with OpenStructure. Depending on your platform, the examples are
-located at a different location:</p>
-<blockquote>
-<ul class="simple">
-<li>on <em>MacOS X</em> the files are in /Applications/OpenStructure/Examples</li>
-<li>on <em>Linux</em> and <em>Windows</em> PREFIX/share/openstructure/examples, where PREFIX is
-the path to the directory containing OpenStructure.</li>
-</ul>
-</blockquote>
-<div class="section" id="starting-dng">
-<h3>Starting DNG<a class="headerlink" href="#starting-dng" title="Permalink to this headline">¶</a></h3>
-<p>The graphical user interface of OpenStructure is called DNG (Dino/DeepView Next
-Generation). To start it,</p>
-<blockquote>
-<ul class="simple">
-<li>on <em>MacOS X</em> double click DNG.app in /Applications/OpenStructure</li>
-<li>on <em>Windows</em> double click dng.bat inside the PREFIX/bin directory</li>
-<li>on <em>Linux</em> fire up a terminal change into the OpenStructure installation
-directory and type ‘bin/dng’. If you have the binary directory in the PATH,
-typing dng is sufficient.</li>
-</ul>
-</blockquote>
-</div>
-<div class="section" id="interactive-python-shell">
-<h3>Interactive Python Shell<a class="headerlink" href="#interactive-python-shell" title="Permalink to this headline">¶</a></h3>
-<p>Now we will enter commands in the Python Shell (in the screenshot above, the
-python shell is located at the bottom of the main window). If you want to get
-more information on any object, function or class, the python help command may
-be useful. For example:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># get list of methods of EntityView</span>
-<span class="n">help</span><span class="p">(</span><span class="n">mol</span><span class="o">.</span><span class="n">EntityView</span><span class="p">)</span>
-<span class="c"># get help for method Select</span>
-<span class="n">help</span><span class="p">(</span><span class="n">mol</span><span class="o">.</span><span class="n">EntityView</span><span class="o">.</span><span class="n">Select</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-</div>
-</div>
-<div class="section" id="loading-and-inspecting-a-protein-structure">
-<h2>Loading and inspecting a protein structure<a class="headerlink" href="#loading-and-inspecting-a-protein-structure" title="Permalink to this headline">¶</a></h2>
-<p>OpenStructure has a module that is dedicated to deal with input and output of
-data, including sequence alignment formats, protein structures and density data
-and images. If you are reading this tutorial you most certainly have dealt with
-protein structures before and you are most certainly aware that they are usually
-stored in Brookhaven structure files (aka PDB files). The official name for
-molecules stored in a PDB file is an entity. You will hear this word all the
-time, but you can replace the word entity with molecule in your head.</p>
-<p>To load a PDB file, type</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">fragment</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadPDB</span><span class="p">(</span><span class="s">'/path/to/examples/entity/fragment.pdb'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>This will load the fragment from the specified file ‘fragment.pdb’ and store the result in fragment. For more information on the LoadPDB function, type</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">help</span><span class="p">(</span><span class="n">io</span><span class="o">.</span><span class="n">LoadPDB</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Now let’s inspect what we just loaded:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">print</span> <span class="n">fragment</span><span class="o">.</span><span class="n">chain_count</span>
-<span class="k">print</span> <span class="n">fragment</span><span class="o">.</span><span class="n">residue_count</span>
-<span class="k">print</span> <span class="n">fragment</span><span class="o">.</span><span class="n">atom_count</span>
-</pre></div>
-</div>
-</blockquote>
-<p>As you can see, our fragment consists of one peptide chain of 12 amino acids and
-has 81 atoms in total. Now let’s examine our fragment in more detail. Enter the
-command</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">residue</span> <span class="ow">in</span> <span class="n">fragment</span><span class="o">.</span><span class="n">residues</span><span class="p">:</span>
- <span class="k">print</span> <span class="n">residue</span>
-</pre></div>
-</div>
-</blockquote>
-<p>This will print a list of all residues in the fragment. Similarly to get a list
-of atoms, use:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">atom</span> <span class="ow">in</span> <span class="n">fragment</span><span class="o">.</span><span class="n">atoms</span><span class="p">:</span>
- <span class="k">print</span> <span class="n">atom</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Of course, we can also get a list of atoms grouped by residues:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">residue</span> <span class="ow">in</span> <span class="n">fragment</span><span class="o">.</span><span class="n">residues</span><span class="p">:</span>
- <span class="k">print</span> <span class="n">residue</span><span class="p">,</span> <span class="s">'has'</span><span class="p">,</span> <span class="n">residue</span><span class="o">.</span><span class="n">atom_count</span><span class="p">,</span> <span class="s">'atom(s).'</span>
- <span class="k">for</span> <span class="n">atom</span> <span class="ow">in</span> <span class="n">residue</span><span class="o">.</span><span class="n">atoms</span><span class="p">:</span>
- <span class="k">print</span> <span class="s">' '</span><span class="p">,</span> <span class="n">atom</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">atom</span><span class="o">.</span><span class="n">pos</span>
-</pre></div>
-</div>
-</blockquote>
-<p>And, for completeness, we will first group them by chain, then by residues.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">chain</span> <span class="ow">in</span> <span class="n">fragments</span><span class="o">.</span><span class="n">chains</span><span class="p">:</span>
- <span class="k">print</span> <span class="s">'chain'</span><span class="p">,</span> <span class="n">chain</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="s">'has'</span><span class="p">,</span> <span class="n">chain</span><span class="o">.</span><span class="n">residue_count</span><span class="p">,</span> <span class="s">'residue(s)'</span>
- <span class="k">for</span> <span class="n">residue</span> <span class="ow">in</span> <span class="n">chain</span><span class="o">.</span><span class="n">residues</span><span class="p">:</span>
- <span class="k">print</span> <span class="s">' '</span><span class="p">,</span> <span class="n">residue</span><span class="p">,</span> <span class="s">'has'</span><span class="p">,</span> <span class="n">residue</span><span class="o">.</span><span class="n">atom_count</span><span class="p">,</span> <span class="s">'atom(s).'</span>
- <span class="k">for</span> <span class="n">atom</span> <span class="ow">in</span> <span class="n">residue</span><span class="o">.</span><span class="n">atoms</span><span class="p">:</span>
- <span class="k">print</span> <span class="s">' '</span><span class="p">,</span> <span class="n">atom</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">atom</span><span class="o">.</span><span class="n">pos</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Aah, wait! A protein fragment would not be complete without bonds: Let’s see
-what bonds we have in there:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">for</span> <span class="n">bond</span> <span class="ow">in</span> <span class="n">fragment</span><span class="o">.</span><span class="n">bonds</span><span class="p">:</span>
- <span class="k">print</span> <span class="n">bond</span>
-</pre></div>
-</div>
-</blockquote>
-<p>From these short code examples we already see how the entity is structured: On
-one hand we have a hierarchy of chains, residues and atoms. On the other hand,
-we have bonds that form a network overlayed on the hierarchy. This is
-illustrated in the picture on the left. An important feature of entities is that
-we can always assume that the hierarchy is intact. You will never find an atom
-without residues, no residue can exist without a parent chain and chains belong
-always to an entity.</p>
-</div>
-<div class="section" id="let-there-be-shiny-graphics">
-<h2>Let There Be Shiny Graphics<a class="headerlink" href="#let-there-be-shiny-graphics" title="Permalink to this headline">¶</a></h2>
-<p>For visually inspecting the fragment, we now create a graphical representation
-of the entity:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">go</span><span class="o">=</span><span class="n">gfx</span><span class="o">.</span><span class="n">Entity</span><span class="p">(</span><span class="s">"Fragment"</span><span class="p">,</span> <span class="n">fragment</span><span class="p">)</span>
-<span class="n">scene</span><span class="o">.</span><span class="n">Add</span><span class="p">(</span><span class="n">go</span><span class="p">)</span>
-<span class="n">scene</span><span class="o">.</span><span class="n">CenterOn</span><span class="p">(</span><span class="n">go</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Now you will see the fragment in the 3D window (left):</p>
-<p></p>
-<p>Use the mouse to rotate, zoom in an shift the camera. Double clicking on an atom will center the camera on that atom.</p>
-</div>
-<div class="section" id="introduction-to-views">
-<h2>Introduction to Views<a class="headerlink" href="#introduction-to-views" title="Permalink to this headline">¶</a></h2>
-<p>Often during processing and visualisation of data, only parts of a protein
-structure are of interest. This realisation has had a major impact on the design
-of OpenStructure and is tied very deeply into the core of the framework.
-Subparts of structure are modeled as so-called <tt class="xref py py-class docutils literal"><span class="pre">EntityViews</span></tt>. You can think of them as a selection of chains, residues,
-atoms and bonds of an entity. A views has almost the same interface as the
-underlying entity, making it very easy to mix entity views with handles in
-Python due to the dynamic nature of the language. An algorithm that is written
-for entities will almost always (with some care) also work for
-<tt class="xref py py-class docutils literal"><span class="pre">EntityHandles</span></tt>. This is referred to as <a class="reference external" href="http://en.wikipedia.org/wiki/Duck_typing">duck-typing</a> (I don’ t care if it is a duck as
-long as it looks like a duck), a concept used all over the place in Python.
-
-A typical view can be seen in the image on the left. The view consists of one
-chain, one residue and two atoms. Again the same rule applies: No atom can be
-part of the view without it’s residue. In this example, no bonds are included,
-since there is at most one atom per bond in the original structure.</p>
-<p>To familiarize yourself with the concept of views, we will use the fragment in
-the 3D window.</p>
-<dl class="docutils">
-<dt>We will use several ways to select parts of our fragment:</dt>
-<dd><ul class="first last simple">
-<li>By using a dedicated query language</li>
-<li>By manually constructing a view</li>
-</ul>
-</dd>
-</dl>
-</div>
-<div class="section" id="the-query-language">
-<h2>The Query Language<a class="headerlink" href="#the-query-language" title="Permalink to this headline">¶</a></h2>
-<p>The first way to select parts of a structure is with a dedicated mini-language,
-called [“the query language”](docs/tut/query.html). In the Python Shell, type</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">go</span><span class="o">.</span><span class="n">selection</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">''</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>A green halo will be displayed around the selected parts (image in the middle).</p>
-<p>As you can see the previous statement created a “full view”, containing all the
-chains, residues, atoms and bonds. To select lysine residues, type</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">go</span><span class="o">.</span><span class="n">selection</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'rname=LYS'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>As you can see (image in the middle), the only lysine residue is now
-highlighted in the 3D window, because it was the only one matching the predicate
-“residue name must be equal to LYS”. Several such predicates can be combined
-with boolean operators such as <em>and</em> and <em>or</em>. To select residues with residue
-number 1 to 3, the following statement will do the job:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">go</span><span class="o">.</span><span class="n">selection</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'rnum>=1 and rnum<=3'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>but this is very cumbersome. That’s why there is a shortcut to this statement.
-You can specify a range of values.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">go</span><span class="o">.</span><span class="n">selection</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'rnum=1:3'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>For a complete description of what you can do with the query language, have a
-look at the <a class="reference internal" href="mol/base/query.html"><em>Queries</em></a>.</p>
-</div>
-<div class="section" id="constructing-views-manually">
-<h2>Constructing Views Manually<a class="headerlink" href="#constructing-views-manually" title="Permalink to this headline">¶</a></h2>
-<p>Sometimes the query language Is Not Enough (TM). For these cases the
-construction of manual entities becomes neccessary. This is pretty straight
-forward:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">view</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">CreateEmptyView</span><span class="p">()</span>
-<span class="n">ca</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">FindAtom</span><span class="p">(</span><span class="s">'A'</span><span class="p">,</span> <span class="n">mol</span><span class="o">.</span><span class="n">ResNum</span><span class="p">(</span><span class="mf">1</span><span class="p">),</span> <span class="s">'CA'</span><span class="p">)</span>
-<span class="n">cb</span><span class="o">=</span><span class="n">fragment</span><span class="o">.</span><span class="n">FindAtom</span><span class="p">(</span><span class="s">'A'</span><span class="p">,</span> <span class="n">mol</span><span class="o">.</span><span class="n">ResNum</span><span class="p">(</span><span class="mf">1</span><span class="p">),</span> <span class="s">'CB'</span><span class="p">)</span>
-<span class="n">view</span><span class="o">.</span><span class="n">AddAtom</span><span class="p">(</span><span class="n">ca</span><span class="p">)</span>
-<span class="n">view</span><span class="o">.</span><span class="n">AddAtom</span><span class="p">(</span><span class="n">cb</span><span class="p">)</span>
-<span class="n">go</span><span class="o">.</span><span class="n">SetSelection</span><span class="p">(</span><span class="n">view</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>The last step sets our constructed view as the current selection, displaying it
-in the 3D window. As you can see, C-alpha and C-beta of the first residue are
-not connected by bonds, even though both atoms are in the view. You have either
-to add the bond manually with</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">ca_cb</span><span class="o">=</span><span class="n">ca</span><span class="o">.</span><span class="n">FindBondToAtom</span><span class="p">(</span><span class="n">cb</span><span class="p">)</span>
-<span class="n">view</span><span class="o">.</span><span class="n">AddBond</span><span class="p">(</span><span class="n">ca_cb</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>Or as a very convenient shortcut ‘view.AddAllInclusiveBonds()’ to add all bonds
-that have both bonding partners in the view.</p>
-<p>Don’t forget to call update the selection of the graphics object to see what
-view you have created.</p>
-</div>
-<div class="section" id="saving-an-entity">
-<h2>Saving an Entity<a class="headerlink" href="#saving-an-entity" title="Permalink to this headline">¶</a></h2>
-<p>Saving an entity (or a view) is a breeze:</p>
-<p>Type</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">io</span><span class="o">.</span><span class="n">SavePDB</span><span class="p">(</span><span class="n">fragment</span><span class="p">,</span> <span class="s">'full.pdb'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>to save the full view. To save only the backbone atoms, we can first select the
-backbone atoms and then save it:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">io</span><span class="o">.</span><span class="n">SavePDB</span><span class="p">(</span><span class="n">fragment</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'aname=CA,C,N,O'</span><span class="p">),</span> <span class="s">'backbone.pdb'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-</div>
-<div class="section" id="loading-images-and-density-maps">
-<h2>Loading images and density maps<a class="headerlink" href="#loading-images-and-density-maps" title="Permalink to this headline">¶</a></h2>
-<p>Openstructure features a <a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> module that is dedicated to the
-manipulation of
-images/density maps. The images or density maps can either be one-, two- or
-three-dimensional. The most common formats used in x-ray and electron
-crystallography and atomic force microscope are supported in addition to several
-general purpose image formats. See <cite>supported file formats</cite> for details.
-The <a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> module was originally developed as part of the Image
-Processing Library & Toolbox IPLT. More documentation and examples can also be
-found on the <a class="reference external" href="http://www.iplt.org">IPLT website</a>.</p>
-<p>To load a density map, type</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="nb">map</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadImage</span><span class="p">(</span><span class="s">'/path/to/examples/map/1ppt.map'</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>This will load the fragment density map from the specified file ‘fragment.map’
-and store the result in fragment_map.</p>
-<p>Now let’s inspect what we just loaded:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">print</span> <span class="nb">map</span><span class="o">.</span><span class="n">GetPixelSampling</span><span class="p">()</span>
-</pre></div>
-</div>
-</blockquote>
-<p>We can see that the sampling is set to 1.0 Angstroems in all three dimensions.</p>
-</div>
-<div class="section" id="manipulating-images-and-density-maps">
-<h2>Manipulating images and density maps<a class="headerlink" href="#manipulating-images-and-density-maps" title="Permalink to this headline">¶</a></h2>
-<p>The algorithms used for manipulation of an image are found in the
-<a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> module. Therefore before using an algorithm we first have to
-import the <a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> module.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">from</span> <span class="nn">ost</span> <span class="k">import</span> <span class="n">img</span>
-</pre></div>
-</div>
-</blockquote>
-<p>The <a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> module provides a wide range of algorithm to manipulate
-image data. Here for the example we use a LowPassFilter to restrict the
-resolution of the density map.</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">map_filtered</span><span class="o">=</span><span class="nb">map</span><span class="o">.</span><span class="n">Apply</span><span class="p">(</span><span class="n">img</span><span class="o">.</span><span class="n">alg</span><span class="o">.</span><span class="n">LowPassFilter</span><span class="p">(</span><span class="mf">3.0</span><span class="p">))</span>
-</pre></div>
-</div>
-</blockquote>
-<p>The filtered map is stored in a new variable called fragment_map_filtered.</p>
-</div>
-<div class="section" id="displaying-images-and-density-maps">
-<h2>Displaying images and density maps<a class="headerlink" href="#displaying-images-and-density-maps" title="Permalink to this headline">¶</a></h2>
-<p>Now that we have a filtered map it’s time to have a look at it. There are
-fundamentally two ways to visualize 3-dimensional density maps. One is by
-drawing isosurfaces. These are conceputally similar to contour lines used in
-cartography: every point on an isosurface has the same density value.
-Isosurfaces are easy to create in OpenStructure:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">go</span><span class="o">=</span><span class="n">gfx</span><span class="o">.</span><span class="n">MapIso</span><span class="p">(</span><span class="s">"filtered"</span><span class="p">,</span> <span class="n">map_filtered</span><span class="p">,</span><span class="mf">0.5</span><span class="p">)</span>
-<span class="n">scene</span><span class="o">.</span><span class="n">Add</span><span class="p">(</span><span class="n">go</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>The other way to visualize a 3-dimensional map is by showing one 2-dimensional
-density slice at a time, allowing the user to move through the slices. In
-OpenStructure this is achieved using a DataViewer docs/tut/imgdataviewer.html).
-A DataViewer showing the filtered map is created using the following command:</p>
-<blockquote>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">gui</span><span class="o">.</span><span class="n">CreateDataViewer</span><span class="p">(</span><span class="n">map_filtered</span><span class="p">)</span>
-</pre></div>
-</div>
-</blockquote>
-<p>This command displays a panel showing one slice of the density map lying on a
-particular (x,y) plane in the coordinate reference system.
-The ‘z’ and ‘x’ keys can be used to move to slices lying at a lower or higher
-coordinate along the ‘z’ axis, allowing the examination of
-the full 3-dimensional volume.</p>
-<p>A more detailed explanation of the <a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a> module can be found in the
-tutorial section for <a class="reference internal" href="img/base/img.html#module-ost.img" title="Images and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">img</span></tt></a>.</p>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="install.html" title="Installing OpenStructure"
- >next</a> |</li>
- <li class="right" >
- <a href="index.html" title="OpenStructure documentation"
- >previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/io/formats.html b/doc/build/io/formats.html
deleted file mode 100644
index c32ed7c8e3622792a3d98a643bb1fd4bfa0f5f00..0000000000000000000000000000000000000000
--- a/doc/build/io/formats.html
+++ /dev/null
@@ -1,194 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Supported File Formats — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Supported File Formats</a><ul>
-<li><a class="reference internal" href="#structure-file-formats">Structure File Formats</a><ul>
-<li><a class="reference internal" href="#pdb-brookhaven-pdb-file">PDB - Brookhaven PDB File</a></li>
-<li><a class="reference internal" href="#pqr">PQR</a></li>
-<li><a class="reference internal" href="#crd-card-format-file-used-by-charmm">CRD - CARD format file used by CHARMM</a></li>
-<li><a class="reference internal" href="#sdf">SDF</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#sequence-file-formats">Sequence File Formats</a><ul>
-<li><a class="reference internal" href="#fasta">FASTA</a></li>
-<li><a class="reference internal" href="#clustalw">ClustalW</a></li>
-<li><a class="reference internal" href="#promod">Promod</a></li>
-<li><a class="reference internal" href="#pir">PIR</a></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/io/formats.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="supported-file-formats">
-<h1>Supported File Formats<a class="headerlink" href="#supported-file-formats" title="Permalink to this headline">¶</a></h1>
-<div class="section" id="structure-file-formats">
-<h2>Structure File Formats<a class="headerlink" href="#structure-file-formats" title="Permalink to this headline">¶</a></h2>
-<p>The following file formats are supported by <a class="reference internal" href="io.html#ost.io.LoadEntity" title="ost.io.LoadEntity"><tt class="xref py py-func docutils literal"><span class="pre">LoadEntity()</span></tt></a>.</p>
-<div class="section" id="pdb-brookhaven-pdb-file">
-<h3>PDB - Brookhaven PDB File<a class="headerlink" href="#pdb-brookhaven-pdb-file" title="Permalink to this headline">¶</a></h3>
-<p>Fine grained control over PDB file import is available via the
-<a class="reference internal" href="io.html#ost.io.LoadPDB" title="ost.io.LoadPDB"><tt class="xref py py-func docutils literal"><span class="pre">LoadPDB()</span></tt></a> function. The PDB importer support loading gzipped PDB
-files. gzipped PDB files are detected by the .gz file extension.</p>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>ent, pdb, ent.gz, pdb.gz</dd>
-<dt><em>Format Name</em></dt>
-<dd>pdb</dd>
-</dl>
-</div>
-<div class="section" id="pqr">
-<h3>PQR<a class="headerlink" href="#pqr" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>pqr</dd>
-<dt><em>Format Name</em></dt>
-<dd>pqr</dd>
-</dl>
-</div>
-<div class="section" id="crd-card-format-file-used-by-charmm">
-<h3>CRD - CARD format file used by CHARMM<a class="headerlink" href="#crd-card-format-file-used-by-charmm" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>crd</dd>
-</dl>
-</div>
-<div class="section" id="sdf">
-<h3>SDF<a class="headerlink" href="#sdf" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>sdf</dd>
-</dl>
-</div>
-</div>
-<div class="section" id="sequence-file-formats">
-<h2>Sequence File Formats<a class="headerlink" href="#sequence-file-formats" title="Permalink to this headline">¶</a></h2>
-<div class="section" id="fasta">
-<h3>FASTA<a class="headerlink" href="#fasta" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>fasta, fna, fas, fa, fsa</dd>
-<dt><em>Format Name</em></dt>
-<dd>fasta</dd>
-</dl>
-</div>
-<div class="section" id="clustalw">
-<h3>ClustalW<a class="headerlink" href="#clustalw" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>aln</dd>
-<dt><em>Format Name</em></dt>
-<dd>clustal</dd>
-</dl>
-</div>
-<div class="section" id="promod">
-<h3>Promod<a class="headerlink" href="#promod" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>ali</dd>
-<dt><em>Format Name</em></dt>
-<dd>promod</dd>
-</dl>
-</div>
-<div class="section" id="pir">
-<h3>PIR<a class="headerlink" href="#pir" title="Permalink to this headline">¶</a></h3>
-<dl class="docutils">
-<dt><em>Recognized File Extensions</em></dt>
-<dd>pir</dd>
-<dt><em>Format Name</em></dt>
-<dd>pir</dd>
-</dl>
-</div>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/io/io.html b/doc/build/io/io.html
deleted file mode 100644
index 642fb68bafc2f3813543834cbb5be89919232022..0000000000000000000000000000000000000000
--- a/doc/build/io/io.html
+++ /dev/null
@@ -1,279 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>io - Input and Output of Sequences, Structures and Maps — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../_static/jquery.js"></script>
- <script type="text/javascript" src="../_static/underscore.js"></script>
- <script type="text/javascript" src="../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../index.html" />
- <link rel="next" title="Creating a New Module" href="../newmodule.html" />
- <link rel="prev" title="ost.settings - Locate Files and Retrieve Preferences" href="../base/base.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../newmodule.html" title="Creating a New Module"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../base/base.html" title="ost.settings - Locate Files and Retrieve Preferences"
- accesskey="P">previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#"><tt class="docutils literal"><span class="pre">io</span></tt> - Input and Output of Sequences, Structures and Maps</a><ul>
-<li><a class="reference internal" href="#molecular-structures">Molecular Structures</a><ul>
-<li><a class="reference internal" href="#loading-molecular-structures">Loading Molecular Structures</a></li>
-<li><a class="reference internal" href="#saving-molecular-structures">Saving Molecular Structures</a></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="../base/base.html"
- title="previous chapter"><tt class="docutils literal docutils literal"><span class="pre">ost.settings</span></tt> - Locate Files and Retrieve Preferences</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../newmodule.html"
- title="next chapter">Creating a New Module</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../_sources/io/io.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.io">
-<span id="io-input-and-output-of-sequences-structures-and-maps"></span><h1><a class="reference internal" href="#module-ost.io" title="Input and output of sequences, structures and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">io</span></tt></a> - Input and Output of Sequences, Structures and Maps<a class="headerlink" href="#module-ost.io" title="Permalink to this headline">¶</a></h1>
-<p>The io module deals with input and output of <a class="reference internal" href="../mol/base/entity.html#ost.mol.EntityHandle" title="ost.mol.EntityHandle"><tt class="xref py py-class docutils literal"><span class="pre">entities</span></tt></a>, <a class="reference internal" href="../seq/base/seq.html#ost.seq.AlignmentHandle" title="ost.seq.AlignmentHandle"><tt class="xref py py-class docutils literal"><span class="pre">alignments</span></tt></a>, and
-<tt class="xref py py-class docutils literal"><span class="pre">images</span></tt>. Importers for common file formats such
-as PDB, SDF, FASTA, CLUSTAL W, DX and CHARMM trajectory files are available.</p>
-<div class="section" id="molecular-structures">
-<h2>Molecular Structures<a class="headerlink" href="#molecular-structures" title="Permalink to this headline">¶</a></h2>
-<div class="section" id="loading-molecular-structures">
-<h3>Loading Molecular Structures<a class="headerlink" href="#loading-molecular-structures" title="Permalink to this headline">¶</a></h3>
-<p>The <a class="reference internal" href="#module-ost.io" title="Input and output of sequences, structures and density maps"><tt class="xref py py-mod docutils literal"><span class="pre">io</span></tt></a> modules offers several ways to load molecular structures
-depending on your requirements. The most general way is offered by
-<a class="reference internal" href="#ost.io.LoadEntity" title="ost.io.LoadEntity"><tt class="xref py py-func docutils literal"><span class="pre">LoadEntity()</span></tt></a>, which will automatically detect the file format based
-on the file extension.</p>
-<dl class="function">
-<dt id="ost.io.LoadEntity">
-<tt class="descclassname">ost.io.</tt><tt class="descname">LoadEntity</tt><big>(</big><em>filename</em>, <em>format='auto'</em><big>)</big><a class="headerlink" href="#ost.io.LoadEntity" title="Permalink to this definition">¶</a></dt>
-<dd><p>Load entity from disk. If format is set to ‘auto’, the function guesses the
-filetype based on the extension of the file. Files ending in ‘.pdb’, ‘.ent’,
-‘.ent.gz’, ‘.pdb.gz’ will automatically be loaded as PDB files, for example.
-For files without or exotic extensions, the format can be set explicitly as
-the second parameter.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># recognizes SDF file by file extension</span>
-<span class="n">ent</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadEntity</span><span class="p">(</span><span class="s">'file.sdf'</span><span class="p">)</span>
-
-<span class="c"># In this case, there is no file extensions, so you have to say it's a</span>
-<span class="c"># SDF file explicitly</span>
-<span class="n">ent</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadEntity</span><span class="p">(</span><span class="s">'file'</span><span class="p">,</span> <span class="s">'sdf'</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>For a list of file formats supported by <a class="reference internal" href="#ost.io.LoadEntity" title="ost.io.LoadEntity"><tt class="xref py py-func docutils literal"><span class="pre">LoadEntity()</span></tt></a>, see <a class="reference internal" href="formats.html"><em>Supported File Formats</em></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first"><tt class="xref py py-exc docutils literal"><span class="pre">IOUnknownFormatException</span></tt> if the format string supplied
-is not recognized or the file format can not be detected based on the
-file extension</p>
-<p class="last"><tt class="xref py py-exc docutils literal"><span class="pre">IOException</span></tt> if the import fails due to an erroneous or
-inexistent file</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<p>Some of the formats have a dedicated function that allows you to tweak many
-parameters that affect the import. PDB files can be loaded with
-<a class="reference internal" href="#ost.io.LoadPDB" title="ost.io.LoadPDB"><tt class="xref py py-func docutils literal"><span class="pre">LoadPDB()</span></tt></a>. It offers a tighter control over the exact loading
-behaviour.</p>
-<dl class="function">
-<dt id="ost.io.LoadPDB">
-<tt class="descclassname">ost.io.</tt><tt class="descname">LoadPDB</tt><big>(</big><em>filename</em>, <em>restrict_chains=''</em>, <em>no_hetatms=False</em>, <em>fault_tolerant=False</em>, <em>load_multi=False</em>, <em>join_spread_atom_records=False</em>, <em>calpha_only=False</em><big>)</big><a class="headerlink" href="#ost.io.LoadPDB" title="Permalink to this definition">¶</a></dt>
-<dd><p>Load PDB file from disk and returns one or more entities. Several options
-allow to customize the exact behaviour of the PDB import.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>restrict_chains</strong> – If not an empty string, only chains listed in the
-string will be imported.</li>
-<li><strong>fault_tolerant</strong> – If True, the import will succeed, even if the
-PDB contains faulty records. The faulty records will be ignored and import
-continues as if the records haven’t been present.</li>
-<li><strong>no_hetatms</strong> – If set to True, HETATM records will be ignored</li>
-<li><strong>load_multi</strong> – If set to True, a list of entities will be returned instead
-of only the first. This is useful when dealing with multi-PDB files.</li>
-<li><strong>join_spread_atom_records</strong> – If set to true, atom records belonging to the
-same residue are joined, even if they do not appear sequentially in the PDB
-file.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Return type:</th><td class="field-body"><p class="first"><pending_xref py:class py:module=”ost.io” refdoc=”io/io” refdomain=”py” refexplicit=”False” reftarget=”ost.mol.EntityHandle” reftype=”class”><literal classes=”xref py py-class”>EntityHandle</literal></pending_xref> or a list thereof if <cite>load_multi</cite> is
-True.</p>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first last"><tt class="xref py py-exc docutils literal"><span class="pre">IOException</span></tt> if the import fails due to an erroneous or
-inexistent file</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-<div class="section" id="saving-molecular-structures">
-<h3>Saving Molecular Structures<a class="headerlink" href="#saving-molecular-structures" title="Permalink to this headline">¶</a></h3>
-<p>Saving a complete entity or a view is a matter of calling
-<a class="reference internal" href="#ost.io.SaveEntity" title="ost.io.SaveEntity"><tt class="xref py py-func docutils literal"><span class="pre">SaveEntity()</span></tt></a>.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">ent</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadEntity</span><span class="p">(</span><span class="s">'protein.pdb'</span><span class="p">)</span>
-<span class="c"># save full entity</span>
-<span class="n">io</span><span class="o">.</span><span class="n">SaveEntity</span><span class="p">(</span><span class="n">ent</span><span class="p">,</span> <span class="s">'full.pdb'</span><span class="p">)</span>
-<span class="c"># only save C-alpha atoms</span>
-<span class="n">io</span><span class="o">.</span><span class="n">SaveEntity</span><span class="p">(</span><span class="n">ent</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'aname=CA and peptide=true'</span><span class="p">),</span> <span class="s">'calpha.pdb'</span><span class="p">)</span>
-</pre></div>
-</div>
-<p><a class="reference internal" href="#ost.io.SavePDB" title="ost.io.SavePDB"><tt class="xref py py-func docutils literal"><span class="pre">SavePDB()</span></tt></a> provides a simple way to save several entities into one
-file:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">ent</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadEntity</span><span class="p">(</span><span class="s">'protein.pdb'</span><span class="p">)</span>
-<span class="c"># Save complete entity</span>
-<span class="n">io</span><span class="o">.</span><span class="n">SavePDB</span><span class="p">(</span><span class="n">ent</span><span class="p">,</span> <span class="s">'full.pdb'</span><span class="p">)</span>
-<span class="c"># Save chain A and chain B separately</span>
-<span class="n">io</span><span class="o">.</span><span class="n">SavePDB</span><span class="p">([</span><span class="n">ent</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'cname=A'</span><span class="p">),</span> <span class="n">ent</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">'cname=B'</span><span class="p">)],</span> <span class="s">'split.pdb'</span><span class="p">)</span>
-</pre></div>
-</div>
-<dl class="function">
-<dt id="ost.io.SaveEntity">
-<tt class="descclassname">ost.io.</tt><tt class="descname">SaveEntity</tt><big>(</big><em>ent</em>, <em>filename</em>, <em>format='auto'</em><big>)</big><a class="headerlink" href="#ost.io.SaveEntity" title="Permalink to this definition">¶</a></dt>
-<dd><p>Save entity to disk. If format is set to ‘auto’, the function guesses the
-filetype based on the file extension, otherwise the supplied format is checked
-against the available export plugins.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>ent</strong> (<em>EntityHandleEntityView</em>) – The entity to be saved</li>
-<li><strong>filename</strong> – The filename</li>
-<li><strong>format</strong> – Name of the format</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first last"><tt class="xref py py-exc docutils literal"><span class="pre">IOUnknownFormatException</span></tt> if the format string supplied
-is not recognized or the file format can not be detected based on the
-file extension</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.io.SavePDB">
-<tt class="descclassname">ost.io.</tt><tt class="descname">SavePDB</tt><big>(</big><em>models</em>, <em>filename</em><big>)</big><a class="headerlink" href="#ost.io.SavePDB" title="Permalink to this definition">¶</a></dt>
-<dd><p>Save entity or list of entities to disk. If a list of entities is supplied the
-PDB file will be saved as a multi PDB file. Each of the entities is wrapped
-into a MODEL/ENDMDL pair.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>models</strong> – The entity or list of entities (handles or views) to be saved</li>
-<li><strong>filename</strong> – The filename</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../newmodule.html" title="Creating a New Module"
- >next</a> |</li>
- <li class="right" >
- <a href="../base/base.html" title="ost.settings - Locate Files and Retrieve Preferences"
- >previous</a> |</li>
- <li><a href="../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/modindex.html b/doc/build/modindex.html
deleted file mode 100644
index 04c9268b5362d77c9155a12eb692b3d09dc87c80..0000000000000000000000000000000000000000
--- a/doc/build/modindex.html
+++ /dev/null
@@ -1,128 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Global Module Index — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/default.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_MODINDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
-
-
-
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="" title="Global Module Index"
- accesskey="M">modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
-
- <h1 id="global-module-index">Global Module Index</h1>
-
-
- <a href="#cap-O"><strong>O</strong></a>
- <hr/>
-
- <table width="100%" class="indextable" cellspacing="0" cellpadding="2"><tr class="pcap"><td></td><td> </td><td></td></tr>
- <tr class="cap"><td></td><td><a name="cap-O"><strong>O</strong></a></td><td></td></tr><tr>
- <td><img src="_static/minus.png" id="toggle-1"
- class="toggler" style="display: none" alt="-" /></td>
- <td>
- <tt class="xref">ost</tt></td><td>
- <em></em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="conop/conop.html#module-ost.conop"><tt class="xref">ost.conop</tt></a></td><td>
- <em>The conop modules implement different strategies to derive
-connectivity information of molecules.</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="geom/geom.html#module-ost.geom"><tt class="xref">ost.geom</tt></a></td><td>
- <em>Functions and classes for vectors, matrices and geometrical
-objects in 2, 3 and four dimensions</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="img/base/img.html#module-ost.img"><tt class="xref">ost.img</tt></a></td><td>
- <em>Images and density maps</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="img/alg/alg.html#module-ost.img.alg"><tt class="xref">ost.img.alg</tt></a></td><td>
- <em>Image processing algorithms</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="io/io.html#module-ost.io"><tt class="xref">ost.io</tt></a></td><td>
- <em>Input and output of sequences, structures and density maps</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="mol/base/mol.html#module-ost.mol"><tt class="xref">ost.mol</tt></a></td><td>
- <em>Contains classes and functions to deal with molecular structures
-and surfaces</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="seq/base/seq.html#module-ost.seq"><tt class="xref">ost.seq</tt></a></td><td>
- <em>Contains classes and functions to deal with sequences and
-alignments</em></td></tr><tr class="cg-1">
- <td></td>
- <td>
- <a href="base/base.html#module-ost.settings"><tt class="xref">ost.settings</tt></a></td><td>
- <em>Helper Functions to Locate Files and Retrieve Preferences</em></td></tr>
- </table>
-
-
- </div>
- </div>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" /> <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="" title="Global Module Index"
- accesskey="M">modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 0.5.2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/mol/base/editors.html b/doc/build/mol/base/editors.html
deleted file mode 100644
index 03dbb7af5ee136a541926c008dcbfa41f198d7bd..0000000000000000000000000000000000000000
--- a/doc/build/mol/base/editors.html
+++ /dev/null
@@ -1,346 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Editors — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="up" title="mol – Molecular structures and surfaces" href="mol.html" />
- <link rel="next" title="Queries" href="query.html" />
- <link rel="prev" title="The Molecular Entity" href="entity.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="query.html" title="Queries"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="entity.html" title="The Molecular Entity"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="mol.html" accesskey="U"><tt class="docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Editors</a><ul>
-<li><a class="reference internal" href="#edit-modes">Edit Modes</a></li>
-<li><a class="reference internal" href="#basic-editing-operations">Basic Editing Operations</a></li>
-<li><a class="reference internal" href="#editor-for-the-external-coordinate-system">Editor for the External Coordinate System</a></li>
-<li><a class="reference internal" href="#editor-for-the-internal-coordinate-system">Editor for the Internal Coordinate System</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="entity.html"
- title="previous chapter">The Molecular Entity</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="query.html"
- title="next chapter">Queries</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/mol/base/editors.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="editors">
-<h1>Editors<a class="headerlink" href="#editors" title="Permalink to this headline">¶</a></h1>
-<p>The structure, topology and connectivity of entities is edited via editors. This
-includes operations such as changing atom positions, connecting atoms with bonds
-as well as adding and removing chains, residues and atoms.</p>
-<div class="section" id="edit-modes">
-<h2>Edit Modes<a class="headerlink" href="#edit-modes" title="Permalink to this headline">¶</a></h2>
-<p>Editors support two modes: An unbuffered edit mode and a buffered edit mode. In
-the unbuffered edit mode, dependent information such as the spatial organizer
-and the internal coordinate system (in case of the XCSEditor) are updated after
-every change. In buffered edit mode, the updates are delayed until one of the
-following happens:</p>
-<blockquote>
-<ul class="simple">
-<li>The last editor goes out of scope.</li>
-<li><tt class="xref py py-meth docutils literal"><span class="pre">XCSEditor.UpdateICS()</span></tt> or <tt class="xref py py-meth docutils literal"><span class="pre">ICSEditor.UpdateXCS()</span></tt> is called
-explicitly.</li>
-</ul>
-</blockquote>
-<p>The editors follow the RIAA (resource allocation is initialisation) principle:
-Whenever an editor is requested an internal reference counter is incremented. In
-the destructor, this reference count is decremented. When the count drops to
-zero, the dependent infomation is updated.</p>
-<p>In Python, one can not rely on the destructors being called. It is adviced to
-always put a call to <tt class="xref py py-meth docutils literal"><span class="pre">XCSEditor.UpdateICS()</span></tt> or
-<tt class="xref py py-meth docutils literal"><span class="pre">ICSEditor.UpdateXCS()</span></tt> when the editing is finished. Alternatively, starting from Python version 2.6, one can use the
-<a class="reference external" href="http://docs.python.org/reference/compound_stmts.html#with">with</a> statement
-to make sure the destructor are called and the dependent information is updated.</p>
-</div>
-<div class="section" id="basic-editing-operations">
-<h2>Basic Editing Operations<a class="headerlink" href="#basic-editing-operations" title="Permalink to this headline">¶</a></h2>
-<p>The basic functionality of editors is implemented in the EditorBase class.</p>
-<dl class="class">
-<dt id="ost.mol.EditorBase">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">EditorBase</tt><a class="headerlink" href="#ost.mol.EditorBase" title="Permalink to this definition">¶</a></dt>
-<dd><p>Inherited by <a class="reference internal" href="#ost.mol.XCSEditor" title="ost.mol.XCSEditor"><tt class="xref py py-class docutils literal"><span class="pre">XCSEditor</span></tt></a>, <a class="reference internal" href="#ost.mol.ICSEditor" title="ost.mol.ICSEditor"><tt class="xref py py-class docutils literal"><span class="pre">ICSEditor</span></tt></a>.</p>
-<dl class="method">
-<dt id="ost.mol.EditorBase.InsertChain">
-<tt class="descname">InsertChain</tt><big>(</big><em>chain_name</em><big>)</big><a class="headerlink" href="#ost.mol.EditorBase.InsertChain" title="Permalink to this definition">¶</a></dt>
-<dd><p>Add new chain to the entity</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>chain_name</strong> – The chain’s name. In the scope of an entity, chain names
-are unique. If a chain of the same already exists an
-IntegrityError is raised.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><pending_xref py:class=”EditorBase” py:module=”ost.mol” refdoc=”mol/base/editors” refdomain=”py” refexplicit=”False” reftarget=”ChainHandle” reftype=”class”><literal classes=”xref py py-class”>ChainHandle</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EditorBase.AppendResidue">
-<tt class="descname">AppendResidue</tt><big>(</big><em>chain</em>, <em>residue_name</em><span class="optional">[</span>, <em>res_num</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.mol.EditorBase.AppendResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>Append residue to the end of the chain. If res_num is not given, the
-residue number will be set to the residue number of the last added residue
-plus one. The insertion code is the same.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>chain</strong> (<em>ChainHandle</em>) – Must be a valid chain</li>
-<li><strong>residue_name</strong> – 3-letter-code of the residue, e.g. <tt class="docutils literal"><span class="pre">GLY</span></tt>.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><pending_xref py:class=”EditorBase” py:module=”ost.mol” refdoc=”mol/base/editors” refdomain=”py” refexplicit=”False” reftarget=”ResidueHandle” reftype=”class”><literal classes=”xref py py-class”>ResidueHandle</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EditorBase.InsertAtom">
-<tt class="descname">InsertAtom</tt><big>(</big><em>residue</em>, <em>atom_name</em>, <em>pos</em><span class="optional">[</span>, <em>prop=mol.AtomProp()</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.mol.EditorBase.InsertAtom" title="Permalink to this definition">¶</a></dt>
-<dd><p>Insert new atom and add it to residue. For atoms with alternative atom
-locations use <tt class="xref py py-meth docutils literal"><span class="pre">InsertAltAtom()</span></tt>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>residue</strong> (<em>ResidueHandle</em>) – is the parent residue and must be valid</li>
-<li><strong>atom_name</strong> – is the atom name. While free to choose a name, it is
-adviced to properly name the atoms according to IUPAC
-rules as several algorithms as well as most
-<tt class="xref py py-class docutils literal"><span class="pre">builders</span></tt> in the <tt class="xref py py-mod docutils literal"><span class="pre">conop</span></tt>
-module rely on proper naming.</li>
-<li><strong>pos</strong> (<em>geom.Vec3</em>) – is the position of the atom in global coordinates</li>
-<li><strong>prop</strong> (<em>AtomProp</em>) – are the atom’s properties such as element, van der Waals
-radius charge and so on. The default set of atom
-properties is rather meaningless.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><pending_xref py:class=”EditorBase” py:module=”ost.mol” refdoc=”mol/base/editors” refdomain=”py” refexplicit=”False” reftarget=”AtomHandle” reftype=”class”><literal classes=”xref py py-class”>AtomHandle</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="editor-for-the-external-coordinate-system">
-<h2>Editor for the External Coordinate System<a class="headerlink" href="#editor-for-the-external-coordinate-system" title="Permalink to this headline">¶</a></h2>
-<p>The XCSEditor defines the interface for manipulating the external coordinate
-system. The external coordinate system directly operates on atom positions in
-euclidian space.</p>
-<dl class="class">
-<dt id="ost.mol.XCSEditor">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">XCSEditor</tt><a class="headerlink" href="#ost.mol.XCSEditor" title="Permalink to this definition">¶</a></dt>
-<dd><p>Inherits <a class="reference internal" href="#ost.mol.EditorBase" title="ost.mol.EditorBase"><tt class="xref py py-class docutils literal"><span class="pre">EditorBase</span></tt></a></p>
-<dl class="method">
-<dt id="ost.mol.XCSEditor.ApplyTransform">
-<tt class="descname">ApplyTransform</tt><big>(</big><em>transform</em><big>)</big><a class="headerlink" href="#ost.mol.XCSEditor.ApplyTransform" title="Permalink to this definition">¶</a></dt>
-<dd><p>Apply a transformation the entity transform. The entity transform is a
-global transformation applied to all atoms.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>transform</strong> (<em>geom.Mat4</em>) – The transformation to be applied</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.XCSEditor.SetTransform">
-<tt class="descname">SetTransform</tt><big>(</big><em>transform</em><big>)</big><a class="headerlink" href="#ost.mol.XCSEditor.SetTransform" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the entity transformation. See also <a class="reference internal" href="#ost.mol.XCSEditor.ApplyTransform" title="ost.mol.XCSEditor.ApplyTransform"><tt class="xref py py-meth docutils literal"><span class="pre">ApplyTransform()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>transform</strong> (<em>geom.Mat4</em>) – The transformation to be applied</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.XCSEditor.SetAtomPos">
-<tt class="descname">SetAtomPos</tt><big>(</big><em>atom</em>, <em>pos</em><big>)</big><a class="headerlink" href="#ost.mol.XCSEditor.SetAtomPos" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the (transformed) position of atom. This method will also update the
-original position of the atom by applying the inverse of the entity
-transform.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>atom</strong> (<a class="reference internal" href="entity.html#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><em>ost.mol.AtomHandle</em></a>) – must be a valid atom handle</li>
-<li><strong>pos</strong> (<em>geom.Vec3</em>) – The new position</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.XCSEditor.SetOriginalAtomPos">
-<tt class="descname">SetOriginalAtomPos</tt><big>(</big><em>atom</em>, <em>pos</em><big>)</big><a class="headerlink" href="#ost.mol.XCSEditor.SetOriginalAtomPos" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the origininal (untransformed) position of the atom. This method will
-also update the transformed position by applying the entity transform to
-the original pos.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>atom</strong> (<a class="reference internal" href="entity.html#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><em>ost.mol.AtomHandle</em></a>) – must be a valid atom handle</li>
-<li><strong>pos</strong> (<em>geom.Vec3</em>) – The new untransformed position</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="editor-for-the-internal-coordinate-system">
-<h2>Editor for the Internal Coordinate System<a class="headerlink" href="#editor-for-the-internal-coordinate-system" title="Permalink to this headline">¶</a></h2>
-<p>The <a class="reference internal" href="#ost.mol.ICSEditor" title="ost.mol.ICSEditor"><tt class="xref py py-class docutils literal"><span class="pre">ICSEditor</span></tt></a> is used to manipulate the internal coordinate system that
-is defined by bond lengths and angles. By default the internal coordinate system
-is not calculates. However, upon requesting an <a class="reference internal" href="#ost.mol.ICSEditor" title="ost.mol.ICSEditor"><tt class="xref py py-class docutils literal"><span class="pre">ICSEditor</span></tt></a> for the first
-time, the internal coordinate system is initialized. This involves the build-up
-of a directed-graph for the bond network as well as calculating the internal
-coordinate matrices.</p>
-<p>The use <a class="reference internal" href="#ost.mol.XCSEditor" title="ost.mol.XCSEditor"><tt class="xref py py-class docutils literal"><span class="pre">XCSEditor</span></tt></a> and <a class="reference internal" href="#ost.mol.ICSEditor" title="ost.mol.ICSEditor"><tt class="xref py py-class docutils literal"><span class="pre">ICSEditor</span></tt></a> are mutually exclusive. This
-means that whenever a <a class="reference internal" href="#ost.mol.XCSEditor" title="ost.mol.XCSEditor"><tt class="xref py py-class docutils literal"><span class="pre">XCSEditor</span></tt></a> has pending changes, the results of
-using an <a class="reference internal" href="#ost.mol.ICSEditor" title="ost.mol.ICSEditor"><tt class="xref py py-class docutils literal"><span class="pre">ICSEditor</span></tt></a> is undefined and vice versa.</p>
-<dl class="class">
-<dt id="ost.mol.ICSEditor">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">ICSEditor</tt><a class="headerlink" href="#ost.mol.ICSEditor" title="Permalink to this definition">¶</a></dt>
-<dd><p>Inherits <a class="reference internal" href="#ost.mol.EditorBase" title="ost.mol.EditorBase"><tt class="xref py py-class docutils literal"><span class="pre">EditorBase</span></tt></a></p>
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="query.html" title="Queries"
- >next</a> |</li>
- <li class="right" >
- <a href="entity.html" title="The Molecular Entity"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="mol.html" ><tt class="docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/mol/base/entity.html b/doc/build/mol/base/entity.html
deleted file mode 100644
index 6ad01f1f038aa5497d3daa5d2cf2628fa4a04ae2..0000000000000000000000000000000000000000
--- a/doc/build/mol/base/entity.html
+++ /dev/null
@@ -1,721 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>The Molecular Entity — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="up" title="mol – Molecular structures and surfaces" href="mol.html" />
- <link rel="next" title="Editors" href="editors.html" />
- <link rel="prev" title="mol – Molecular structures and surfaces" href="mol.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="editors.html" title="Editors"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="mol.html" title="mol – Molecular structures and surfaces"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="mol.html" accesskey="U"><tt class="docutils literal docutils literal docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">The Molecular Entity</a><ul>
-<li><a class="reference internal" href="#functions">Functions</a><ul>
-<li><a class="reference internal" href="#boolean-operators">Boolean Operators</a></li>
-<li><a class="reference internal" href="#other-entity-related-functions">Other Entity-Related Functions</a></li>
-</ul>
-</li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="mol.html"
- title="previous chapter"><tt class="docutils literal docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="editors.html"
- title="next chapter">Editors</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/mol/base/entity.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="the-molecular-entity">
-<h1>The Molecular Entity<a class="headerlink" href="#the-molecular-entity" title="Permalink to this headline">¶</a></h1>
-<p>This document describes the <a class="reference internal" href="#ost.mol.EntityHandle" title="ost.mol.EntityHandle"><tt class="xref py py-class docutils literal"><span class="pre">EntityHandle</span></tt></a> and related classes.</p>
-<dl class="function">
-<dt id="ost.mol.CreateEntity">
-<tt class="descclassname">ost.mol.</tt><tt class="descname">CreateEntity</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.CreateEntity" title="Permalink to this definition">¶</a></dt>
-<dd><p>Creates a new entity. The created entity is empty, that is, it does not
-contain any atoms, residues, chains, bonds or torsions. To populate the
-entity, use an <a class="reference internal" href="editors.html"><em>Editors</em></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">The newly created <a class="reference internal" href="#ost.mol.EntityHandle" title="ost.mol.EntityHandle"><tt class="xref py py-class docutils literal"><span class="pre">EntityHandle</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.mol.EntityHandle">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">EntityHandle</tt><a class="headerlink" href="#ost.mol.EntityHandle" title="Permalink to this definition">¶</a></dt>
-<dd><p>The entity class represents a molecular structure. Such a structure is in
-general made up of one or more linear chains of residues, which in turn are
-formed by one or more atoms.</p>
-<p>The interface of entities is tailored to biological macromolecules, but this
-does not prevent it to be used for molecules in general: An entity also
-represent a ligand or a collection of water molecules - hence the rather
-generic name.</p>
-<dl class="method">
-<dt id="ost.mol.EntityHandle.FindChain">
-<tt class="descname">FindChain</tt><big>(</big><em>chain_name</em><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.FindChain" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get chain by name. See also <a class="reference internal" href="#ost.mol.EntityHandle.GetChainList" title="ost.mol.EntityHandle.GetChainList"><tt class="xref py py-meth docutils literal"><span class="pre">GetChainList()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>chain_name</strong> – Chain identifier, e.g. “A”</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A valid <a class="reference internal" href="#ost.mol.ChainHandle" title="ost.mol.ChainHandle"><tt class="xref py py-class docutils literal"><span class="pre">ChainHandle</span></tt></a>, if the entity contains a
-chain with the given name, an invalid
-<a class="reference internal" href="#ost.mol.ChainHandle" title="ost.mol.ChainHandle"><tt class="xref py py-class docutils literal"><span class="pre">ChainHandle</span></tt></a> otherwise.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetChainList">
-<tt class="descname">GetChainList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetChainList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get list of all chains of this entity. To access a single chain, use
-<a class="reference internal" href="#ost.mol.EntityHandle.FindChain" title="ost.mol.EntityHandle.FindChain"><tt class="xref py py-meth docutils literal"><span class="pre">FindChain()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A list of <a class="reference internal" href="#ost.mol.ChainHandle" title="ost.mol.ChainHandle"><tt class="xref py py-class docutils literal"><span class="pre">ChainHandles</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.FindResidue">
-<tt class="descname">FindResidue</tt><big>(</big><em>chain_name</em>, <em>res_num</em><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.FindResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get residue by chain name and residue number. See also
-<a class="reference internal" href="#ost.mol.EntityHandle.GetResidueList" title="ost.mol.EntityHandle.GetResidueList"><tt class="xref py py-meth docutils literal"><span class="pre">GetResidueList()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>chain_name</strong> – Chain identifier, e.g. “A”</li>
-<li><strong>res_num</strong> – residue number</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A valid <a class="reference internal" href="#ost.mol.ResidueHandle" title="ost.mol.ResidueHandle"><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandle</span></tt></a> if the chain exists and
-the chain contains a residue of the given residue
-number, an invalid <a class="reference internal" href="#ost.mol.ResidueHandle" title="ost.mol.ResidueHandle"><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandle</span></tt></a> otherwise.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetResidueList">
-<tt class="descname">GetResidueList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetResidueList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get list of all residues of this entity. To access a single residue, use
-<a class="reference internal" href="#ost.mol.EntityHandle.FindResidue" title="ost.mol.EntityHandle.FindResidue"><tt class="xref py py-meth docutils literal"><span class="pre">FindResidue()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A list of <a class="reference internal" href="#ost.mol.ResidueHandle" title="ost.mol.ResidueHandle"><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandles</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.FindAtom">
-<tt class="descname">FindAtom</tt><big>(</big><em>chain_name</em>, <em>res_num</em>, <em>atom_name</em><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.FindAtom" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get atom by chain name, residue number and atom name. See also
-<a class="reference internal" href="#ost.mol.EntityHandle.GetAtomList" title="ost.mol.EntityHandle.GetAtomList"><tt class="xref py py-meth docutils literal"><span class="pre">GetAtomList()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>chain_name</strong> – Chain identifier, e.g. “A”</li>
-<li><strong>res_num</strong> – residue number</li>
-<li><strong>atom_name</strong> – atom name, e.g. CA</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A valid <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt></a> if an atom matching the
-parameters could be found, an invalid
-<a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt></a> otherwise</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetAtomList">
-<tt class="descname">GetAtomList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetAtomList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get list of all atoms of this entity. To access a single atom, use
-<a class="reference internal" href="#ost.mol.EntityHandle.FindAtom" title="ost.mol.EntityHandle.FindAtom"><tt class="xref py py-meth docutils literal"><span class="pre">FindAtom()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A list of <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandles</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.RequestXCSEditor">
-<tt class="descname">RequestXCSEditor</tt><big>(</big><span class="optional">[</span><em>edit_mode=mol.EditMode.BUFFERED_EDIT</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.RequestXCSEditor" title="Permalink to this definition">¶</a></dt>
-<dd><p>Request <a class="reference internal" href="editors.html#ost.mol.XCSEditor" title="ost.mol.XCSEditor"><tt class="xref py py-class docutils literal"><span class="pre">XCSEditor</span></tt></a> for editing the external coordinate system. This
-call will fail when there are pending changes of the internal coordinate
-system.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>edit_mode</strong> – Must be EditMode.BUFFERED_EDIT or
-EditMode.UNBUFFERED_EDIT. For more details, see the
-editor documentation.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”XCSEditor” reftype=”class”><literal classes=”xref py py-class”>XCSEditor</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.RequestICSEditor">
-<tt class="descname">RequestICSEditor</tt><big>(</big><span class="optional">[</span><em>edit_mode=mol.EditMode.BUFFERED_EDIT</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.RequestICSEditor" title="Permalink to this definition">¶</a></dt>
-<dd><p>Request <a class="reference internal" href="editors.html#ost.mol.ICSEditor" title="ost.mol.ICSEditor"><tt class="xref py py-class docutils literal"><span class="pre">ICSEditor</span></tt></a> for editing the internal coordinate system, such
-as torsions, bond lengths and angle between two bonds. This call will fail
-when there are pending changes of the external coordinate system.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>edit_mode</strong> – Must be EditMode.BUFFERED_EDIT or
-EditMode.UNBUFFERED_EDIT. For more details, see the
-editor documentation.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”ICSEditor” reftype=”class”><literal classes=”xref py py-class”>ICSEditor</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.Select">
-<tt class="descname">Select</tt><big>(</big><em>query</em>, <em>flags</em><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.Select" title="Permalink to this definition">¶</a></dt>
-<dd><p>Perform a selection on the entity. The result of the selection is an
-<a class="reference internal" href="#ost.mol.EntityView" title="ost.mol.EntityView"><tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt></a> which contains usually only a subset of chains,
-residues, atoms and bonds of the original entity.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>query</strong> (<a class="reference internal" href="query.html#Query" title="Query"><em>Query</em></a>) – The query to be executed. See <a class="reference internal" href="query.html#Query" title="Query"><tt class="xref py py-class docutils literal"><span class="pre">Query</span></tt></a> for details.</li>
-<li><strong>flags</strong> – An ORed combination of <tt class="xref py py-class docutils literal"><span class="pre">QueryFlags</span></tt>.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first">An <a class="reference internal" href="#ost.mol.EntityView" title="ost.mol.EntityView"><tt class="xref py py-class docutils literal"><span class="pre">entity</span> <span class="pre">view</span></tt></a>.</p>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first last"><tt class="xref py py-class docutils literal"><span class="pre">QueryError</span></tt> when the query could not be executed due
-to syntactic errors.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.CreateFullView">
-<tt class="descname">CreateFullView</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.CreateFullView" title="Permalink to this definition">¶</a></dt>
-<dd><p>Creates an entity view containing all chains, residues, atoms and bonds of
-this entity.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># these two lines are identical</span>
-<span class="n">full</span><span class="o">=</span><span class="n">ent</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">''</span><span class="p">)</span>
-<span class="n">full</span><span class="o">=</span><span class="n">ent</span><span class="o">.</span><span class="n">CreateFullView</span><span class="p">()</span>
-</pre></div>
-</div>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”EntityView” reftype=”class”><literal classes=”xref py py-class”>EntityView</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.CreateEmptyView">
-<tt class="descname">CreateEmptyView</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.CreateEmptyView" title="Permalink to this definition">¶</a></dt>
-<dd><p>Creates an entity view pointing to this entity, but otherwise empty. This
-method is usually the starting point for manual entity view creation, e.g.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">view</span><span class="o">=</span><span class="n">ent</span><span class="o">.</span><span class="n">CreateEmtpyView</span><span class="p">()</span>
-<span class="k">for</span> <span class="n">atom</span> <span class="ow">in</span> <span class="n">ent</span><span class="o">.</span><span class="n">atoms</span><span class="p">:</span>
- <span class="k">if</span> <span class="n">ComplicatedPredicate</span><span class="p">(</span><span class="n">atom</span><span class="p">):</span>
- <span class="n">view</span><span class="o">.</span><span class="n">AddAtom</span><span class="p">(</span><span class="n">atom</span><span class="p">)</span>
-</pre></div>
-</div>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”EntityView” reftype=”class”><literal classes=”xref py py-class”>EntityView</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.Copy">
-<tt class="descname">Copy</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.Copy" title="Permalink to this definition">¶</a></dt>
-<dd><p>Creates a deep copy of the entity.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A new <a class="reference internal" href="#ost.mol.EntityHandle" title="ost.mol.EntityHandle"><tt class="xref py py-class docutils literal"><span class="pre">EntityHandle</span></tt></a> that is an exact copy of this entity.</td>
-</tr>
-</tbody>
-</table>
-<div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">alternative atom positions are not handled yet.</p>
-</div>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetCenterOfAtoms">
-<tt class="descname">GetCenterOfAtoms</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetCenterOfAtoms" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get center of atoms, that is the average atom position of the entity. Use
-<a class="reference internal" href="#ost.mol.EntityHandle.GetCenterOfMass" title="ost.mol.EntityHandle.GetCenterOfMass"><tt class="xref py py-meth docutils literal"><span class="pre">GetCenterOfMass()</span></tt></a> to calculate the mass-weighted center of the entity.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”geom.Vec3” reftype=”class”><literal classes=”xref py py-class”>geom.Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetCenterOfMass">
-<tt class="descname">GetCenterOfMass</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetCenterOfMass" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates the center of mass of the entity. Use <a class="reference internal" href="#ost.mol.EntityHandle.GetCenterOfAtoms" title="ost.mol.EntityHandle.GetCenterOfAtoms"><tt class="xref py py-meth docutils literal"><span class="pre">GetCenterOfAtoms()</span></tt></a>
-to calculate the non-mass-weighted center of the entity.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”geom.Vec3” reftype=”class”><literal classes=”xref py py-class”>geom.Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetGeometricCenter">
-<tt class="descname">GetGeometricCenter</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetGeometricCenter" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates the mid-point of the axis aligned bounding box of the entity.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><pending_xref py:class=”EntityHandle” py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”geom.Vec3” reftype=”class”><literal classes=”xref py py-class”>geom.Vec3</literal></pending_xref></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.GetMass">
-<tt class="descname">GetMass</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.GetMass" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates the total mass of the entity by summing up the masses of all
-atoms.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">The mass in Dalton</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.Apply">
-<tt class="descname">Apply</tt><big>(</big><em>visitor</em><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.Apply" title="Permalink to this definition">¶</a></dt>
-<dd><p>Apply EntityVisitor to the entity. In Python, you shouldn’t bother using
-this function. EntityVisitory are mainly used in C++ to implement
-algorithms that operate are able to operate on EntityViews or
-EntityHandles.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.EntityHandle.FindWithin">
-<tt class="descname">FindWithin</tt><big>(</big><em>pos</em>, <em>radius</em><big>)</big><a class="headerlink" href="#ost.mol.EntityHandle.FindWithin" title="Permalink to this definition">¶</a></dt>
-<dd><p>Find all atoms in sphere of given radius centered at <em>pos</em>. To turn the
-returned list of atoms into an <a class="reference internal" href="#ost.mol.EntityView" title="ost.mol.EntityView"><tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt></a>, use
-<a class="reference internal" href="#ost.mol.CreateViewFromAtomList" title="ost.mol.CreateViewFromAtomList"><tt class="xref py py-func docutils literal"><span class="pre">CreateViewFromAtomList()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>pos</strong> (<em>geom.Vec3</em>) – Center of sphere</li>
-<li><strong>radius</strong> – The radius of the sphere</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A list of <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandles</span></tt></a></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.mol.ChainHandle">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">ChainHandle</tt><a class="headerlink" href="#ost.mol.ChainHandle" title="Permalink to this definition">¶</a></dt>
-<dd><dl class="method">
-<dt id="ost.mol.ChainHandle.FindResidue">
-<tt class="descname">FindResidue</tt><big>(</big><em>res_num</em><big>)</big><a class="headerlink" href="#ost.mol.ChainHandle.FindResidue" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get residue by residue number. See also <a class="reference internal" href="#ost.mol.ChainHandle.GetResidueList" title="ost.mol.ChainHandle.GetResidueList"><tt class="xref py py-meth docutils literal"><span class="pre">GetResidueList()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>res_num</strong> – residue number</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A valid <a class="reference internal" href="#ost.mol.ResidueHandle" title="ost.mol.ResidueHandle"><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandle</span></tt></a> if the chain contains
-a residue with matching residue number, an invalid
-<a class="reference internal" href="#ost.mol.ResidueHandle" title="ost.mol.ResidueHandle"><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandle</span></tt></a> otherwise.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.ChainHandle.GetResidueList">
-<tt class="descname">GetResidueList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.ChainHandle.GetResidueList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get list of all residues of this chain. For peptide chains, the residues
-are usually ordered from N- to C-terminus.To access a single residue, use
-<a class="reference internal" href="#ost.mol.ChainHandle.FindResidue" title="ost.mol.ChainHandle.FindResidue"><tt class="xref py py-meth docutils literal"><span class="pre">FindResidue()</span></tt></a>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A list of <a class="reference internal" href="#ost.mol.ResidueHandle" title="ost.mol.ResidueHandle"><tt class="xref py py-class docutils literal"><span class="pre">ResidueHandles</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.ChainHandle.FindAtom">
-<tt class="descname">FindAtom</tt><big>(</big><em>res_num</em>, <em>atom_name</em><big>)</big><a class="headerlink" href="#ost.mol.ChainHandle.FindAtom" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get atom by residue number and atom name. See also <a class="reference internal" href="#ost.mol.ChainHandle.GetAtomList" title="ost.mol.ChainHandle.GetAtomList"><tt class="xref py py-meth docutils literal"><span class="pre">GetAtomList()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>res_num</strong> – residue number</li>
-<li><strong>atom_name</strong> – atom name, e.g. CA</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A valid <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt></a> if an atom matching the
-parameters could be found, an invalid
-<a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt></a> otherwise</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.ChainHandle.GetAtomList">
-<tt class="descname">GetAtomList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.ChainHandle.GetAtomList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get list of all atoms of this chain. To access a single atom, use
-<a class="reference internal" href="#ost.mol.ChainHandle.FindAtom" title="ost.mol.ChainHandle.FindAtom"><tt class="xref py py-meth docutils literal"><span class="pre">FindAtom()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body">A list of <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandles</span></tt></a></td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.mol.ResidueHandle">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">ResidueHandle</tt><a class="headerlink" href="#ost.mol.ResidueHandle" title="Permalink to this definition">¶</a></dt>
-<dd><dl class="method">
-<dt id="ost.mol.ResidueHandle.FindAtom">
-<tt class="descname">FindAtom</tt><big>(</big><em>atom_name</em><big>)</big><a class="headerlink" href="#ost.mol.ResidueHandle.FindAtom" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get atom by atom name. See also <a class="reference internal" href="#ost.mol.ResidueHandle.GetAtomList" title="ost.mol.ResidueHandle.GetAtomList"><tt class="xref py py-meth docutils literal"><span class="pre">GetAtomList()</span></tt></a></p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>atom_name</strong> – atom name, e.g. CA</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last">A valid <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt></a> if an atom with the given
-name could be found, an invalid <a class="reference internal" href="#ost.mol.AtomHandle" title="ost.mol.AtomHandle"><tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt></a>
-otherwise</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.mol.ResidueHandle.GetAtomList">
-<tt class="descname">GetAtomList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.mol.ResidueHandle.GetAtomList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get list of all atoms of this residue. To access a single atom, use
-<a class="reference internal" href="#ost.mol.ResidueHandle.FindAtom" title="ost.mol.ResidueHandle.FindAtom"><tt class="xref py py-meth docutils literal"><span class="pre">FindAtom()</span></tt></a>.</p>
-</dd></dl>
-
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.mol.AtomHandle">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">AtomHandle</tt><a class="headerlink" href="#ost.mol.AtomHandle" title="Permalink to this definition">¶</a></dt>
-<dd></dd></dl>
-
-<dl class="class">
-<dt id="ost.mol.EntityView">
-<em class="property">class </em><tt class="descclassname">ost.mol.</tt><tt class="descname">EntityView</tt><a class="headerlink" href="#ost.mol.EntityView" title="Permalink to this definition">¶</a></dt>
-<dd><p>Represents a subpart of an <a class="reference internal" href="#ost.mol.EntityHandle" title="ost.mol.EntityHandle"><tt class="xref py py-class docutils literal"><span class="pre">EntityHandle</span></tt></a>.</p>
-</dd></dl>
-
-<div class="section" id="functions">
-<h2>Functions<a class="headerlink" href="#functions" title="Permalink to this headline">¶</a></h2>
-<div class="section" id="boolean-operators">
-<h3>Boolean Operators<a class="headerlink" href="#boolean-operators" title="Permalink to this headline">¶</a></h3>
-<dl class="function">
-<dt id="ost.mol.Intersection">
-<tt class="descclassname">ost.mol.</tt><tt class="descname">Intersection</tt><big>(</big><em>view_a</em>, <em>view_b</em><big>)</big><a class="headerlink" href="#ost.mol.Intersection" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates and returns the intersection of <cite>view_a</cite> and <cite>view_b</cite>. <cite>view_a</cite>
-and <cite>view_b</cite> must be views of the same entity.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>view_a</strong> – first view</li>
-<li><strong>view_b</strong> – second view</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.mol.Difference">
-<tt class="descclassname">ost.mol.</tt><tt class="descname">Difference</tt><big>(</big><em>view_a</em>, <em>view_b</em><big>)</big><a class="headerlink" href="#ost.mol.Difference" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates and returns the difference between <cite>view_a</cite> and <cite>view_b</cite>. <cite>view_a</cite>
-and <cite>view_b</cite> must be views of the same entity.The returned view will
-contain atoms, residues, chains and bonds that are in <cite>view_a</cite> and not in
-<cite>view_b</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>view_a</strong> – first view</li>
-<li><strong>view_b</strong> – second view</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.mol.Union">
-<tt class="descclassname">ost.mol.</tt><tt class="descname">Union</tt><big>(</big><em>view_a</em>, <em>view_b</em><big>)</big><a class="headerlink" href="#ost.mol.Union" title="Permalink to this definition">¶</a></dt>
-<dd><p>Calculates and returns the union of <cite>view_a</cite> and <cite>view_b</cite>. <cite>view_a</cite>
-and <cite>view_b</cite> must be views of the same entity.The returned view will contain
-all atoms, residues, chains and bonds that are either in <cite>view_a</cite>, <cite>view_b</cite>
-or part of both views.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>view_a</strong> – first view</li>
-<li><strong>view_b</strong> – second view</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-<div class="section" id="other-entity-related-functions">
-<h3>Other Entity-Related Functions<a class="headerlink" href="#other-entity-related-functions" title="Permalink to this headline">¶</a></h3>
-<dl class="function">
-<dt id="ost.mol.CreateViewFromAtomList">
-<tt class="descclassname">ost.mol.</tt><tt class="descname">CreateViewFromAtomList</tt><big>(</big><em>atom_list</em><big>)</big><a class="headerlink" href="#ost.mol.CreateViewFromAtomList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a view made up of the atoms in <em>atom_list</em>. All atoms are required to
-be atoms of the same entity. Duplicate atoms are only added to the view once.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>atom_list</strong> (<em>AtomHandleListAtomViewList</em>) – the atoms</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first"><tt class="xref py py-class docutils literal"><span class="pre">IntegrityError</span></tt> if atoms of different entities are
-encountered</p>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Returns:</th><td class="field-body"><p class="first last"><pending_xref py:class py:module=”ost.mol” refdoc=”mol/base/entity” refdomain=”py” refexplicit=”False” reftarget=”EntityView” reftype=”class”><literal classes=”xref py py-class”>EntityView</literal></pending_xref></p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-</div>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="editors.html" title="Editors"
- >next</a> |</li>
- <li class="right" >
- <a href="mol.html" title="mol – Molecular structures and surfaces"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="mol.html" ><tt class="docutils literal docutils literal docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/mol/base/mol.html b/doc/build/mol/base/mol.html
deleted file mode 100644
index 2e95329b3f97663cab1db90855b3e36c5ba5094f..0000000000000000000000000000000000000000
--- a/doc/build/mol/base/mol.html
+++ /dev/null
@@ -1,143 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>mol – Molecular structures and surfaces — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="next" title="The Molecular Entity" href="entity.html" />
- <link rel="prev" title="conop – Connectivity and Topology of Molecules" href="../../conop/conop.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="entity.html" title="The Molecular Entity"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../../conop/conop.html" title="conop – Connectivity and Topology of Molecules"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h4>Previous topic</h4>
- <p class="topless"><a href="../../conop/conop.html"
- title="previous chapter"><tt class="docutils literal docutils literal docutils literal"><span class="pre">conop</span></tt> – Connectivity and Topology of Molecules</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="entity.html"
- title="next chapter">The Molecular Entity</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/mol/base/mol.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.mol">
-<span id="mol-molecular-structures-and-surfaces"></span><h1><a class="reference internal" href="#module-ost.mol" title="Contains classes and functions to deal with molecular structures and surfaces"><tt class="xref py py-mod docutils literal"><span class="pre">mol</span></tt></a> – Molecular structures and surfaces<a class="headerlink" href="#module-ost.mol" title="Permalink to this headline">¶</a></h1>
-<p>The mol module implement data structure to work with molecular datasets. At its heart lie the <a class="reference internal" href="entity.html#ost.mol.EntityHandle" title="ost.mol.EntityHandle"><tt class="xref py py-class docutils literal"><span class="pre">EntityHandle</span></tt></a> and <a class="reference internal" href="entity.html#ost.mol.EntityView" title="ost.mol.EntityView"><tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt></a> classes which represent molecular structures such as proteins, DNA, RNA and small molecules. There are also classes to deal with molecular surfaces.</p>
-<div class="toctree-wrapper compound">
-<ul>
-<li class="toctree-l1"><a class="reference internal" href="entity.html">The Molecular Entity</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="entity.html#functions">Functions</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="entity.html#boolean-operators">Boolean Operators</a></li>
-<li class="toctree-l3"><a class="reference internal" href="entity.html#other-entity-related-functions">Other Entity-Related Functions</a></li>
-</ul>
-</li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="editors.html">Editors</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="editors.html#edit-modes">Edit Modes</a></li>
-<li class="toctree-l2"><a class="reference internal" href="editors.html#basic-editing-operations">Basic Editing Operations</a></li>
-<li class="toctree-l2"><a class="reference internal" href="editors.html#editor-for-the-external-coordinate-system">Editor for the External Coordinate System</a></li>
-<li class="toctree-l2"><a class="reference internal" href="editors.html#editor-for-the-internal-coordinate-system">Editor for the Internal Coordinate System</a></li>
-</ul>
-</li>
-<li class="toctree-l1"><a class="reference internal" href="query.html">Queries</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="query.html#the-query-language-reference">The query language reference</a><ul>
-<li class="toctree-l3"><a class="reference internal" href="query.html#abbreviations">Abbreviations</a></li>
-</ul>
-</li>
-<li class="toctree-l2"><a class="reference internal" href="query.html#generic-properties-in-queries">Generic Properties in Queries</a></li>
-</ul>
-</li>
-</ul>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="entity.html" title="The Molecular Entity"
- >next</a> |</li>
- <li class="right" >
- <a href="../../conop/conop.html" title="conop – Connectivity and Topology of Molecules"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/mol/base/query.html b/doc/build/mol/base/query.html
deleted file mode 100644
index f94e39e7b86b049599a476500cecaf1366a27aa3..0000000000000000000000000000000000000000
--- a/doc/build/mol/base/query.html
+++ /dev/null
@@ -1,233 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Queries — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="up" title="mol – Molecular structures and surfaces" href="mol.html" />
- <link rel="next" title="seq – Sequences and Alignments" href="../../seq/base/seq.html" />
- <link rel="prev" title="Editors" href="editors.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../../seq/base/seq.html" title="seq – Sequences and Alignments"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="editors.html" title="Editors"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="mol.html" accesskey="U"><tt class="docutils literal docutils literal docutils literal docutils literal docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Queries</a><ul>
-<li><a class="reference internal" href="#the-query-language-reference">The query language reference</a><ul>
-<li><a class="reference internal" href="#abbreviations">Abbreviations</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#generic-properties-in-queries">Generic Properties in Queries</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="editors.html"
- title="previous chapter">Editors</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../../seq/base/seq.html"
- title="next chapter"><tt class="docutils literal docutils literal"><span class="pre">seq</span></tt> – Sequences and Alignments</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/mol/base/query.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="queries">
-<h1>Queries<a class="headerlink" href="#queries" title="Permalink to this headline">¶</a></h1>
-<dl class="class">
-<dt id="Query">
-<em class="property">class </em><tt class="descname">Query</tt><a class="headerlink" href="#Query" title="Permalink to this definition">¶</a></dt>
-<dd><p>Blabla</p>
-</dd></dl>
-
-<p>It is often convenient to highlight or focus certain parts of the structure.
-OpenStructure includes a powerful query system that allows you to perform custom
-selections in a convenient way.</p>
-<p>Please refer to the tutorial on the query language for an introduction.</p>
-<div class="section" id="the-query-language-reference">
-<h2>The query language reference<a class="headerlink" href="#the-query-language-reference" title="Permalink to this headline">¶</a></h2>
-<p>The query consists of one or more predicates combined with boolean
-operators. A predicate takes the form <em>prop op value</em>. Operators are
-one of `` =, !=, >, >=, <=`` and <tt class="docutils literal"><span class="pre"><</span></tt>. A predicate has the following form:
-<em>PROPERTY - OPERATOR - ARGUMENT</em>.</p>
-<p>The following properties may be used in predicates. The supported type of the
-value is given for each property.</p>
-<blockquote>
-<ul class="simple">
-<li><tt class="docutils literal"><span class="pre">rname</span></tt> residue name. type: string</li>
-<li><tt class="docutils literal"><span class="pre">rnum</span></tt> residue number. currently only numeric part is honored.
-type: int</li>
-<li><tt class="docutils literal"><span class="pre">rtype</span></tt> residue type as given by the DSSP code, i.e. H for helix, E
-for extended. type: string</li>
-<li><tt class="docutils literal"><span class="pre">aname</span></tt> atom name. type: string</li>
-<li><tt class="docutils literal"><span class="pre">ele</span></tt> element of atom. type: string</li>
-<li><tt class="docutils literal"><span class="pre">cname</span></tt> chain name. type: string</li>
-<li><tt class="docutils literal"><span class="pre">occ</span></tt> occupancy, between 0 and 1. type: float</li>
-<li><tt class="docutils literal"><span class="pre">abfac</span></tt> B (temperature) factor of atom. type: float</li>
-<li><tt class="docutils literal"><span class="pre">rbfac</span></tt> average B (temperature) factor of residue. type: float.
-Note that this does not work for views as expected. When running a
-second selection statement on a view, all atoms of the residue handle
-and not the view are considered in the calculation</li>
-<li><tt class="docutils literal"><span class="pre">ishetatm</span></tt> whether the atom is a hetorogenous atom. type: bool or int
-(0 for false, 1 for true)</li>
-<li><tt class="docutils literal"><span class="pre">peptide</span></tt> whether the residue is peptide linking. type: bool or int
-(0 for false, 1 for true)</li>
-<li><tt class="docutils literal"><span class="pre">x</span></tt> X coordinate of atom. type: float</li>
-<li><tt class="docutils literal"><span class="pre">y</span></tt> Y coordinate of atom. type: float</li>
-<li><tt class="docutils literal"><span class="pre">z</span></tt> Z coordinate of atom. type: float</li>
-<li><tt class="docutils literal"><span class="pre">rindex</span></tt> index of residue in chain. This index is the same for views
-and handles</li>
-<li>For <a class="reference internal" href="#genprop-in-queries"><em>generic properties in queries</em></a> see below.</li>
-</ul>
-</blockquote>
-<p>Distance-based selections within a given atom position are supported by
-the within statement. To select atoms within 5 Angstrom of the point
-<tt class="docutils literal"><span class="pre">{1,</span> <span class="pre">2,</span> <span class="pre">3}</span></tt>, one would write:</p>
-<p><tt class="docutils literal"><span class="pre">5</span> <span class="pre"><></span> <span class="pre">{1,2,3}</span></tt></p>
-<p>Negation of this expression is possible with the not operator, i.e.</p>
-<p><tt class="docutils literal"><span class="pre">not</span> <span class="pre">5</span> <span class="pre"><></span> <span class="pre">{1,2,3}</span></tt>
-will select atoms that are further than five Angstrom apart from <tt class="docutils literal"><span class="pre">{1,</span> <span class="pre">2</span> <span class="pre">,</span> <span class="pre">3}</span></tt></p>
-<div class="section" id="abbreviations">
-<h3>Abbreviations<a class="headerlink" href="#abbreviations" title="Permalink to this headline">¶</a></h3>
-<p>Two abbreviations exist for convenience:</p>
-<p>Instead of writing</p>
-<p><tt class="docutils literal"><span class="pre">aname=CA</span> <span class="pre">or</span> <span class="pre">aname=C</span> <span class="pre">or</span> <span class="pre">aname=O</span> <span class="pre">or</span> <span class="pre">aname=N</span></tt>,</p>
-<p>one can write</p>
-<p><tt class="docutils literal"><span class="pre">aname=CA,N,C,O</span></tt>.</p>
-<p>For integral value ranges, one can use the colon syntax: instead of</p>
-<p><tt class="docutils literal"><span class="pre">rnum>=10</span> <span class="pre">and</span> <span class="pre">rnum<=20</span></tt></p>
-<p>one can write</p>
-<p><tt class="docutils literal"><span class="pre">rnum=10:20</span></tt></p>
-</div>
-</div>
-<div class="section" id="generic-properties-in-queries">
-<span id="genprop-in-queries"></span><h2>Generic Properties in Queries<a class="headerlink" href="#generic-properties-in-queries" title="Permalink to this headline">¶</a></h2>
-<p>The query language can also be used for numeric generic properties (i.e.
-float and int), but the syntax is slightly different. To access any generic
-properties, it needs to be specified that they are generic and at which level
-they are defined. Therefore, all generic properties start with a <tt class="docutils literal"><span class="pre">g</span></tt>, followed by an <tt class="docutils literal"><span class="pre">a</span></tt>, <tt class="docutils literal"><span class="pre">r</span></tt> or <tt class="docutils literal"><span class="pre">c</span></tt> for atom, residue or chain level respectively.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># set generic properties for atom, residue, chain</span>
-<span class="n">atom_handle</span><span class="o">.</span><span class="n">SetFloatProp</span><span class="p">(</span><span class="s">"testpropatom"</span><span class="p">,</span> <span class="mf">5.2</span><span class="p">)</span>
-<span class="n">resid_handle</span><span class="o">.</span><span class="n">SetFloatProp</span><span class="p">(</span><span class="s">"testpropres"</span><span class="p">,</span> <span class="mf">1.1</span><span class="p">)</span>
-<span class="n">chain_handle</span><span class="o">.</span><span class="n">SetIntProp</span><span class="p">(</span><span class="s">"testpropchain"</span><span class="p">,</span> <span class="mf">10</span><span class="p">)</span>
-
-<span class="c"># query statements</span>
-<span class="n">sel_a</span><span class="o">=</span><span class="n">e</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">"gatestpropatom<=10.0"</span><span class="p">)</span>
-<span class="n">sel_r</span><span class="o">=</span><span class="n">e</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">"grtestpropres=1.0"</span><span class="p">)</span>
-<span class="n">sel_c</span><span class="o">=</span><span class="n">e</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">"gctestpropchain>5"</span><span class="p">)</span>
-</pre></div>
-</div>
-<p>Since generic properties do not need to be defined for all parts of an entity
-(e.g. it could be specified for one single <tt class="xref py py-class docutils literal"><span class="pre">AtomHandle</span></tt>), the query
-statement will throw an error unless you specify a default value in the query
-statement which can be done using a ‘:’ character:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="c"># if one or more atoms have no generic properties</span>
-
-<span class="n">sel</span><span class="o">=</span><span class="n">e</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">"gatestprop=5"</span><span class="p">)</span>
-<span class="c"># this will throw an error</span>
-
-<span class="c"># you can specify a default value:</span>
-<span class="n">sel</span><span class="o">=</span><span class="n">e</span><span class="o">.</span><span class="n">Select</span><span class="p">(</span><span class="s">"gatestprop:1.0=5"</span><span class="p">)</span>
-<span class="c"># this will run through smoothly and use 1.0 as</span>
-<span class="c"># the default value for all atoms that do not</span>
-<span class="c"># have the generic property 'testprop'</span>
-</pre></div>
-</div>
-<p>Using this method, you will be warned if a generic property is not set for all
-atoms, residues or chains unless you specify a default value. So, be careful
-when you do.</p>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../../seq/base/seq.html" title="seq – Sequences and Alignments"
- >next</a> |</li>
- <li class="right" >
- <a href="editors.html" title="Editors"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- <li><a href="mol.html" ><tt class="docutils literal docutils literal docutils literal docutils literal docutils literal docutils literal"><span class="pre">mol</span></tt> – Molecular structures and surfaces</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/newmodule.html b/doc/build/newmodule.html
deleted file mode 100644
index 64ee3d9da535b4e7bfafa016407921620041e484..0000000000000000000000000000000000000000
--- a/doc/build/newmodule.html
+++ /dev/null
@@ -1,385 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Creating a New Module — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
- <link rel="next" title="Using External Programs within OpenStructure" href="external.html" />
- <link rel="prev" title="io - Input and Output of Sequences, Structures and Maps" href="io/io.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="external.html" title="Using External Programs within OpenStructure"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="io/io.html" title="io - Input and Output of Sequences, Structures and Maps"
- accesskey="P">previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#">Creating a New Module</a><ul>
-<li><a class="reference internal" href="#directory-structure">Directory Structure</a></li>
-<li><a class="reference internal" href="#the-module-code">The Module Code</a></li>
-<li><a class="reference internal" href="#the-testing-framework">The Testing Framework</a></li>
-<li><a class="reference internal" href="#the-python-wrapper">The Python Wrapper</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="io/io.html"
- title="previous chapter"><tt class="docutils literal docutils literal docutils literal"><span class="pre">io</span></tt> - Input and Output of Sequences, Structures and Maps</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="external.html"
- title="next chapter">Using External Programs within OpenStructure</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="_sources/newmodule.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="creating-a-new-module">
-<h1>Creating a New Module<a class="headerlink" href="#creating-a-new-module" title="Permalink to this headline">¶</a></h1>
-<p>OpenStructure can be extended by writing additional modules. A module will
-usually consist of a set of C++ classes and methods, most of which will also be
-exported to Python. It is also possible to write modules completely in Python.</p>
-<p>The build system of OpenStructure is quite simple. The main difference to other
-projects is the use of a so-called stage directory. The stage directory
-replicates the normal layout of a standard Linux directory structure, with an
-‘include’ directory for the headers, a ‘lib’ directory containing the shared
-library files, a <cite>bin</cite> directory for the executables and a ‘share’ directory
-for the platform-independent data like icons, images and examples.</p>
-<p>OpenStructure uses <a class="reference external" href="http://www.cmake.org">CMake</a> to build the project. The
-rules for the build-system are defined in <cite>CMakeLists.txt</cite> files. When running
-<a class="reference external" href="http://cmake.org">CMake</a>, the files are compiled and copied into stage. The
-real installation, if necessary, happens at a later stage. This is referred to
-as staging of the files.</p>
-<p>If a new module is written following the guidelines in this page, it will be
-seamlessly included in the build system and will then be available form both
-the DNG python console and the OpenStructure command line as any other native
-module.</p>
-<p>As a first step, a new directory structure must be created to accommodate the
-new module.</p>
-<div class="section" id="directory-structure">
-<h2>Directory Structure<a class="headerlink" href="#directory-structure" title="Permalink to this headline">¶</a></h2>
-<p>For the purpose of this example, let’s assume we are creating a new module
-called ‘mod’ (for ‘modeling’). Let’s create a directory named <cite>mod</cite> under the
-‘modules’ directory in the OpenStructure development tree, and populate it with
-the three subdirectories <cite>src</cite>, <cite>pymod</cite>, and <cite>tests</cite>. Then we add a
-<cite>CMakeLists.txt</cite> file in the ‘mod’ directory, consisting of three lines:</p>
-<div class="highlight-bash"><div class="highlight"><pre>add_subdirectory<span class="o">(</span>src<span class="o">)</span>
-add_subdirectory<span class="o">(</span>pymod<span class="o">)</span>
-add_subdirectory<span class="o">(</span>tests<span class="o">)</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="the-module-code">
-<h2>The Module Code<a class="headerlink" href="#the-module-code" title="Permalink to this headline">¶</a></h2>
-<p>In the <cite>src</cite> subdirectory we put the code that implements the functionality of
-the new module, plus a <cite>config.hh</cite> header file.</p>
-<p>Here is a skeleton of one of the files in the directory , <cite>modeling_new_class.hh</cite>:</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#ifndef OST_MOD_NEW_CLASS_H</span>
-<span class="cp">#define OST_MOD_NEW_CLASS_H</span>
-
-<span class="cp">#include <ost/mod/module_config.hh></span>
-
-<span class="c">// All other necessary includes go here</span>
-
-<span class="k">namespace</span> <span class="n">ost</span> <span class="p">{</span> <span class="k">namespace</span> <span class="n">mod</span> <span class="p">{</span>
-
-<span class="k">class</span> <span class="nc">DLLEXPORT_OST_MOD</span> <span class="n">NewClass</span> <span class="p">{</span>
- <span class="k">public</span><span class="o">:</span>
- <span class="kt">void</span> <span class="n">NewMethod</span><span class="p">();</span>
-
- <span class="c">// All declarations of NewClass go here</span>
-
-<span class="p">};</span>
-
-<span class="p">}}</span> <span class="c">// namespaces</span>
-
-<span class="cp">#endif</span>
-</pre></div>
-</div>
-<p>And here is the skeleton of the corresponding <cite>modeling_new_class.cc</cite> file:</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#include "modeling_new_class.hh"</span>
-
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">ost</span><span class="o">::</span><span class="n">mol</span><span class="p">;</span>
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">ost</span><span class="o">::</span><span class="n">mod</span><span class="p">;</span>
-
-<span class="c">// All other necessary includes and namespace directives</span>
-<span class="c">// go here</span>
-
-<span class="kt">void</span> <span class="n">NewClass</span><span class="o">::</span><span class="n">NewMethod</span><span class="p">()</span><span class="o">:</span>
-<span class="p">{</span>
- <span class="c">// Implementation</span>
-<span class="p">}</span>
-
-<span class="c">// Implementation code for NewClass goes here</span>
-</pre></div>
-</div>
-<p>Obviously, the <cite>src</cite> directory can contain many files, each implementing classes
-and functions that will end up in the module. In order to build and stage
-the module shared library, a <cite>CMakeLists.txt</cite> file needs to be written for the
-<cite>src</cite> directory:</p>
-<div class="highlight-bash"><div class="highlight"><pre><span class="nb">set</span><span class="o">(</span>OST_MOD_SOURCES
-modeling_new_class.cc
-// All other <span class="nb">source </span>files
-<span class="o">)</span>
-
-<span class="nb">set</span><span class="o">(</span>OST_MOD_HEADERS
-modeling_new_class.hh
-// All other header files
-<span class="o">)</span>
-
- module<span class="o">(</span>NAME mod SOURCES <span class="s2">"${OST_MOD_SOURCES}"</span>
- HEADERS <span class="k">${</span><span class="nv">OST_MOD_HEADERS</span><span class="k">}</span>
- DEPENDS_ON mol mol_alg<span class="o">)</span>
-</pre></div>
-</div>
-<p>The line containing the <cite>DEPENDS_ON</cite> directive lists all the modules on which
-the new module depends (in this case <tt class="xref py py-mod docutils literal"><span class="pre">mol</span></tt> and <tt class="xref py py-mod docutils literal"><span class="pre">ost.mol.alg</span></tt>). The
-<cite>module</cite> macro will take care of staging the headers, in this case into
-<cite>ost/mod</cite> and compiling, linking and staging of a library with the name
-<cite>libost_mod.so</cite> (<cite>libost_gmod.dylib</cite> on MacOS X).</p>
-<div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">Due to a limitation in the built-int install command of CMake, for modules
-that have their headers in several directories, it is required to group the
-headers by directory, leading to a call of module like:</p>
-</div>
-<div class="highlight-bash"><div class="highlight"><pre>module<span class="o">(</span>NAME mol SOURCES atom_handle.cc impl/atom_impl.cc
- HEADERS atom_impl.hh IN_DIR impl
- atom_handle.hh<span class="o">)</span>
-</pre></div>
-</div>
-<p>The <cite>module_config.hh</cite> header is required for each module to setup the
-environment on Windows: Each public class, method and function needs to marked
-with <cite>DLLEXPORT</cite> or <cite>DLLIMPORT</cite> to teach the linker where to look for the
-symbol. The correct use of either <cite>DLLIMPORT</cite> and <cite>DLLEXPORT</cite> is depending on
-the context: While compiling a header file that is part of the same shared
-library, <cite>DLLEXPORT</cite> must be used. When compiling a header that is part of
-an external shared library, <cite>DLLIMPORT</cite> must be used. A typical module_config
-header looks like this:</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#ifndef OST_MOD_MODULE_CONFIG_HH</span>
-<span class="cp">#define OST_MOD_MODULE_CONFIG_HH</span>
-
-<span class="cp">#include <ost/base.hh></span>
-
-<span class="cp">#if defined(OST_MODULE_OST_MOD)</span>
-<span class="cp"># define DLLEXPORT_OST_MOD DLLEXPORT</span>
-<span class="cp">#else</span>
-<span class="cp"># define DLLEXPORT_OST_MOD DLLIMPORT</span>
-<span class="cp">#endif</span>
-<span class="cp">#endif</span>
-</pre></div>
-</div>
-</div>
-<div class="section" id="the-testing-framework">
-<h2>The Testing Framework<a class="headerlink" href="#the-testing-framework" title="Permalink to this headline">¶</a></h2>
-<p>The <cite>tests</cite> directory contains code for unit tests. The code is compiled and
-executed when one invokes compilation using the ‘make check’ command. Tests are
-run by means of the <a class="reference external" href="http://www.boost.org/doc/libs/1_37_0/libs/test/doc/html/index.html">Boost Unitests Library</a>, which is
-used throughout OpenStructure. Before coding the test routines, the required
-skeleton needs to be put in place.</p>
-<p>The main code is put into ‘tests.cc’, which will become the test executable:</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#include <boost/test/unit_test.hpp></span>
-<span class="k">using</span> <span class="n">boost</span><span class="o">::</span><span class="n">unit_test_framework</span><span class="o">::</span><span class="n">test_suite</span><span class="p">;</span>
-
-<span class="cp">#include "test_modeling.hh"</span>
-
-<span class="n">test_suite</span><span class="o">*</span>
-<span class="n">unit_unit_test_suite</span><span class="p">(</span> <span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">*</span> <span class="n">argv</span><span class="p">[]</span> <span class="p">)</span> <span class="p">{</span>
- <span class="n">std</span><span class="o">::</span><span class="n">auto_ptr</span><span class="o"><</span><span class="n">test_suite</span><span class="o">></span> <span class="n">test</span><span class="p">(</span><span class="n">BOOST_TEST_SUITE</span><span class="p">(</span> <span class="s">"Module Mod Test"</span> <span class="p">));</span>
-
- <span class="n">test</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">CreateModelingTest</span><span class="p">());</span>
-
- <span class="k">return</span> <span class="n">test</span><span class="p">.</span><span class="n">release</span><span class="p">();</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>The most relevant line adds the test suite for the new module to the global test
-list. The test suite is created by the factory function CreateModelingTest(),
-which is declared in the <cite>test_modeling.hh</cite> header file.</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#ifndef OST_MOD_TEST_MODELING_H</span>
-<span class="cp">#define OST_MOD_TEST_MODELING_H</span>
-
-<span class="cp">#include <boost/test/unit_test.hpp></span>
-<span class="k">using</span> <span class="n">boost</span><span class="o">::</span><span class="n">unit_test_framework</span><span class="o">::</span><span class="n">test_suite</span><span class="p">;</span>
-
-<span class="n">test_suite</span><span class="o">*</span> <span class="n">CreateModelingTest</span><span class="p">();</span>
-
-<span class="cp">#endif</span>
-</pre></div>
-</div>
-<p>The definition of the factory function is found in the actual test code,
-which we put in <cite>test_modeling.cc</cite>. Here is a skeleton version of that file:</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#include "test_modeling.hh"</span>
-
-<span class="c">// additional include statements will go here</span>
-
-<span class="k">namespace</span> <span class="n">test_modeling</span> <span class="p">{</span>
-
- <span class="kt">void</span> <span class="n">test</span><span class="p">()</span>
- <span class="p">{</span>
- <span class="c">// test code will go here</span>
- <span class="p">}</span>
-
-<span class="p">}</span>
-
-<span class="n">test_suite</span><span class="o">*</span> <span class="n">CreateModelingTest</span><span class="p">()</span>
-<span class="p">{</span>
- <span class="k">using</span> <span class="k">namespace</span> <span class="n">test_modeling</span><span class="p">;</span>
- <span class="n">test_suite</span><span class="o">*</span> <span class="n">ts</span><span class="o">=</span><span class="n">BOOST_TEST_SUITE</span><span class="p">(</span><span class="s">"Modeling Test"</span><span class="p">);</span>
- <span class="n">ts</span><span class="o">-></span><span class="n">add</span><span class="p">(</span><span class="n">BOOST_TEST_CASE</span><span class="p">(</span><span class="o">&</span><span class="n">test</span><span class="p">));</span>
-
- <span class="k">return</span> <span class="n">ts</span><span class="p">;</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>In this file, all the normal Boost Test Library macros and functions can be used. (For example <cite>BOOST_CHECK</cite>, <cite>BOOST_FAIL</cite>, etc.)</p>
-<p>Here is finally the build script skeleton that needs to be put into
-<cite>mod/tests/</cite>:</p>
-<div class="highlight-bash"><div class="highlight"><pre><span class="nb">set</span><span class="o">(</span>OST_MOD_UNIT_TESTS
-tests.cc
-test_modeling.cc
-<span class="o">)</span>
-
-ost_unittest<span class="o">(</span>mod <span class="s2">"${OST_MOD_UNIT_TESTS}"</span><span class="o">)</span>
-target_link_libraries<span class="o">(</span>ost_mol ost_mol_alg ost_mod<span class="o">)</span>
-</pre></div>
-</div>
-<p>In the last line the call to the ‘target_link_libraries’ function contains the
-names of the modules on which the ‘mod’ unit test code depends (in this case,
-the <tt class="xref py py-mod docutils literal"><span class="pre">mol</span></tt> and <tt class="xref py py-mod docutils literal"><span class="pre">ost.mol.alg</span></tt> modules), in addition to the <cite>mod</cite> module
-itself.</p>
-</div>
-<div class="section" id="the-python-wrapper">
-<h2>The Python Wrapper<a class="headerlink" href="#the-python-wrapper" title="Permalink to this headline">¶</a></h2>
-<p>Finally, the module API is exported to Python using the <a class="reference external" href="http://www.boost.org/doc/libs/1_37_0/libs/python/doc/index.html">Boost Python
-Library</a>.
-In <cite>mod/pymod</cite>, the wrapper code for the classes in the new module is put into a
-file named <cite>wrap_mod.cc</cite>:</p>
-<div class="highlight-cpp"><div class="highlight"><pre><span class="cp">#include <boost/python.hpp></span>
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">boost</span><span class="o">::</span><span class="n">python</span><span class="p">;</span>
-
-<span class="cp">#include <ost/mod/modeling_new_class.hh></span>
-
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">ost</span><span class="o">::</span><span class="n">mol</span><span class="p">;</span>
-<span class="k">using</span> <span class="k">namespace</span> <span class="n">ost</span><span class="o">::</span><span class="n">mod</span><span class="p">;</span>
-
-<span class="c">// All other necessary includes and namespace directives</span>
-<span class="c">// go here</span>
-
-<span class="n">BOOST_PYTHON_MODULE</span><span class="p">(</span><span class="n">_mod</span><span class="p">)</span>
-<span class="p">{</span>
- <span class="n">class_</span><span class="o"><</span><span class="n">NewClass</span><span class="o">></span><span class="p">(</span><span class="s">"NewClass"</span><span class="p">,</span> <span class="n">init</span><span class="o"><></span><span class="p">()</span> <span class="p">)</span>
- <span class="p">.</span><span class="n">def</span><span class="p">(</span><span class="s">"NewMethod"</span><span class="p">,</span> <span class="o">&</span><span class="n">NewClass</span><span class="o">::</span><span class="n">NewMethod</span><span class="p">)</span>
- <span class="p">;</span>
-
- <span class="c">// All other Boost Python code goes here</span>
-<span class="p">}</span>
-</pre></div>
-</div>
-<p>The <cite>mod/pymod</cite> directory must obviously contain a <cite>CMakeLists.txt</cite> file:</p>
-<div class="highlight-bash"><div class="highlight"><pre><span class="nb">set</span><span class="o">(</span>OST_MOD_PYMOD_SOURCES
-wrap_mod.cc
-<span class="o">)</span>
-
-pymod<span class="o">(</span>NAME mod OUTPUT_DIR ost/mod
- CPP <span class="k">${</span><span class="nv">OST_MOD_PYMOD_SOURCES</span><span class="k">}</span> PY __init__.py<span class="o">)</span>
-</pre></div>
-</div>
-<p>The directory should also contain an <cite>__init.py__</cite> file with the
-following content:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="k">from</span> <span class="nn">_mod</span> <span class="k">import</span> <span class="o">*</span>
-</pre></div>
-</div>
-<p>In case one wants to implement Python-only functionality for the new module, any
-number of function definitions can be added to the <cite>__init.py__</cite> file.</p>
-<p>That’s it!. The next time the OpenStructure project is compiled, the new module
-will be built and made available at both the C++ and the Python level.</p>
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="external.html" title="Using External Programs within OpenStructure"
- >next</a> |</li>
- <li class="right" >
- <a href="io/io.html" title="io - Input and Output of Sequences, Structures and Maps"
- >previous</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/objects.inv b/doc/build/objects.inv
deleted file mode 100644
index f489ec21d842feab5134991b871162854a84c5ae..0000000000000000000000000000000000000000
Binary files a/doc/build/objects.inv and /dev/null differ
diff --git a/doc/build/py-modindex.html b/doc/build/py-modindex.html
deleted file mode 100644
index 8effa89f372d97766b7b30a558c386d004704fe5..0000000000000000000000000000000000000000
--- a/doc/build/py-modindex.html
+++ /dev/null
@@ -1,167 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Python Module Index — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
-
-
- <script type="text/javascript">
- DOCUMENTATION_OPTIONS.COLLAPSE_INDEX = true;
- </script>
-
-
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="#" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
-
- <h1>Python Module Index</h1>
-
- <div class="modindex-jumpbox">
- <a href="#cap-c"><strong>c</strong></a> |
- <a href="#cap-g"><strong>g</strong></a> |
- <a href="#cap-i"><strong>i</strong></a> |
- <a href="#cap-m"><strong>m</strong></a> |
- <a href="#cap-s"><strong>s</strong></a>
- </div>
-
- <table class="indextable modindextable" cellspacing="0" cellpadding="2">
- <tr class="pcap"><td></td><td> </td><td></td></tr>
- <tr class="cap"><td></td><td><a name="cap-c">
- <strong>c</strong></a></td><td></td></tr>
- <tr>
- <td></td>
- <td>
- <a href="conop/conop.html#module-ost.conop"><tt class="xref">ost.conop</tt></a></td><td>
- <em>The conop modules implement different strategies to derive
-connectivity information of molecules.</em></td></tr>
- <tr class="pcap"><td></td><td> </td><td></td></tr>
- <tr class="cap"><td></td><td><a name="cap-g">
- <strong>g</strong></a></td><td></td></tr>
- <tr>
- <td></td>
- <td>
- <a href="geom/geom.html#module-ost.geom"><tt class="xref">ost.geom</tt></a></td><td>
- <em>Functions and classes for vectors, matrices and geometrical
-objects in 2, 3 and four dimensions</em></td></tr>
- <tr class="pcap"><td></td><td> </td><td></td></tr>
- <tr class="cap"><td></td><td><a name="cap-i">
- <strong>i</strong></a></td><td></td></tr>
- <tr>
- <td><img src="_static/minus.png" id="toggle-1"
- class="toggler" style="display: none" alt="-" /></td>
- <td>
- <a href="img/base/img.html#module-ost.img"><tt class="xref">ost.img</tt></a></td><td>
- <em>Images and density maps</em></td></tr>
- <tr class="cg-1">
- <td></td>
- <td>
- <a href="img/alg/alg.html#module-ost.img.alg"><tt class="xref">ost.img.alg</tt></a></td><td>
- <em>Image processing algorithms</em></td></tr>
- <tr>
- <td></td>
- <td>
- <a href="io/io.html#module-ost.io"><tt class="xref">ost.io</tt></a></td><td>
- <em>Input and output of sequences, structures and density maps</em></td></tr>
- <tr class="pcap"><td></td><td> </td><td></td></tr>
- <tr class="cap"><td></td><td><a name="cap-m">
- <strong>m</strong></a></td><td></td></tr>
- <tr>
- <td></td>
- <td>
- <a href="mol/base/mol.html#module-ost.mol"><tt class="xref">ost.mol</tt></a></td><td>
- <em>Contains classes and functions to deal with molecular structures
-and surfaces</em></td></tr>
- <tr class="pcap"><td></td><td> </td><td></td></tr>
- <tr class="cap"><td></td><td><a name="cap-s">
- <strong>s</strong></a></td><td></td></tr>
- <tr>
- <td></td>
- <td>
- <a href="seq/base/seq.html#module-ost.seq"><tt class="xref">ost.seq</tt></a></td><td>
- <em>Contains classes and functions to deal with sequences and
-alignments</em></td></tr>
- <tr>
- <td></td>
- <td>
- <a href="base/base.html#module-ost.settings"><tt class="xref">ost.settings</tt></a></td><td>
- <em>Helper Functions to Locate Files and Retrieve Preferences</em></td></tr>
- </table>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="#" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/search.html b/doc/build/search.html
deleted file mode 100644
index ecf7c106484116fb2332e5817dd3f44bf6f5bf3a..0000000000000000000000000000000000000000
--- a/doc/build/search.html
+++ /dev/null
@@ -1,102 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>Search — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="_static/jquery.js"></script>
- <script type="text/javascript" src="_static/underscore.js"></script>
- <script type="text/javascript" src="_static/doctools.js"></script>
- <script type="text/javascript" src="_static/searchtools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="index.html" />
- <script type="text/javascript">
- jQuery(function() { Search.loadIndex("searchindex.js"); });
- </script>
-
-
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <h1 id="search-documentation">Search</h1>
- <div id="fallback" class="admonition warning">
- <script type="text/javascript">$('#fallback').hide();</script>
- <p>
- Please activate JavaScript to enable the search
- functionality.
- </p>
- </div>
- <p>
- From here you can search these documents. Enter your search
- words into the box below and click "search". Note that the search
- function will automatically search for all of the words. Pages
- containing fewer words won't appear in the result list.
- </p>
- <form action="" method="get">
- <input type="text" name="q" value="" />
- <input type="submit" value="search" />
- <span id="search-progress" style="padding-left: 10px"></span>
- </form>
-
- <div id="search-results">
-
- </div>
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li><a href="index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/build/searchindex.js b/doc/build/searchindex.js
deleted file mode 100644
index b2b30b7d3fe952503799c6d054482ad0d9eb09a5..0000000000000000000000000000000000000000
--- a/doc/build/searchindex.js
+++ /dev/null
@@ -1 +0,0 @@
-Search.setIndex({objects:{"":{Query:[2,3,1],GenericPropertyContainer:[14,3,1]},"ost.seq.SequenceHandle":{attached_view:[4,5,1],AttachView:[4,2,1],GetFirstNonGap:[4,2,1],sequence_offset:[4,5,1],GetLastNonGap:[4,2,1],SetName:[4,2,1],GetGaplessString:[4,2,1],GetResidueIndex:[4,2,1],GetSequenceOffset:[4,2,1],GetAttachedView:[4,2,1],HasAttachedView:[4,2,1],"__str__":[4,2,1],gapless_string:[4,5,1],SetSequenceOffset:[4,2,1],GetPos:[4,2,1],GetName:[4,2,1],"__len__":[4,2,1],name:[4,5,1]},"ost.io":{SaveEntity:[15,1,1],SavePDB:[15,1,1],LoadPDB:[15,1,1],LoadEntity:[15,1,1]},"ost.geom.AlignedCuboid":{GetMax:[3,2,1],GetMin:[3,2,1]},ost:{conop:[7,0,0],seq:[4,0,0],img:[9,0,0],settings:[6,0,0],geom:[18,0,0],io:[15,0,0],mol:[10,0,0]},"ost.geom.Sphere":{origin:[3,5,1],GetOrigin:[3,2,1],SetOrigin:[3,2,1],radius:[3,5,1],SetRadius:[3,2,1],GetRadius:[3,2,1]},"ost.mol.EntityHandle":{FindChain:[1,2,1],CreateFullView:[1,2,1],GetGeometricCenter:[1,2,1],GetChainList:[1,2,1],GetResidueList:[1,2,1],GetCenterOfMass:[1,2,1],GetMass:[1,2,1],RequestXCSEditor:[1,2,1],CreateEmptyView:[1,2,1],GetCenterOfAtoms:[1,2,1],FindAtom:[1,2,1],FindResidue:[1,2,1],GetAtomList:[1,2,1],Apply:[1,2,1],FindWithin:[1,2,1],Copy:[1,2,1],RequestICSEditor:[1,2,1],Select:[1,2,1]},"ost.geom.Circle2":{GetCircumference:[3,2,1],GetArea:[3,2,1],SetCenter:[3,2,1],GetCenter:[3,2,1],SetRadius:[3,2,1],GetRadius:[3,2,1]},"ost.geom.Mat3":{Identity:[16,4,1]},"ost.geom.Mat2":{Identity:[16,4,1]},"ost.geom.Mat4":{ExtractTranslation:[16,2,1],PasteRotation:[16,2,1],ExtractRotation:[16,2,1],Identity:[16,4,1]},"ost.geom.Plane":{origin:[3,5,1],normal:[3,5,1],GetOrigin:[3,2,1],GetNormal:[3,2,1],p:[3,5,1],GetP:[3,2,1]},"ost.conop":{RuleBasedBuilder:[7,3,1],Builder:[7,3,1]},"ost.geom.Line2":{origin:[3,5,1],GetOrigin:[3,2,1],direction:[3,5,1],GetDirection:[3,2,1],At:[3,2,1]},"ost.geom.Line3":{origin:[3,5,1],GetOrigin:[3,2,1],direction:[3,5,1],GetDirection:[3,2,1],At:[3,2,1]},"ost.geom.Cuboid":{axis_c:[3,5,1],axis_a:[3,5,1],axis_b:[3,5,1],center:[3,5,1]},"ost.geom.CuboidAxis":{half_extent:[3,5,1],GetVector:[3,2,1],vector:[3,5,1],GetExtent:[3,2,1],extent:[3,5,1],GetHalfExtent:[3,2,1]},"ost.mol.XCSEditor":{SetTransform:[8,2,1],SetOriginalAtomPos:[8,2,1],ApplyTransform:[8,2,1],SetAtomPos:[8,2,1]},"ost.settings":{Locate:[6,1,1],FileNotFound:[6,6,1],GetValue:[6,1,1]},"ost.conop.RuleBasedBuilder":{OnMissingAtom:[7,2,1],CheckResidueCompleteness:[7,2,1],IdentifyResidue:[7,2,1],OnUnknownAtom:[7,2,1]},"ost.img.alg.HighpassFilter":{SetLimit:[0,2,1],GetLimit:[0,2,1]},"ost.mol.ChainHandle":{GetAtomList:[1,2,1],GetResidueList:[1,2,1],FindAtom:[1,2,1],FindResidue:[1,2,1]},"ost.conop.Builder":{GuessAtomElement:[7,2,1],AssignBackboneTorsionsToResidue:[7,2,1],CheckResidueCompleteness:[7,2,1],IdentifyResidue:[7,2,1],IsBondFeasible:[7,2,1],ConnectAtomsOfResidue:[7,2,1],CompleteAtoms:[7,2,1],ConnectResidueToPrev:[7,2,1],DoesPeptideBondExist:[7,2,1],IsResidueComplete:[7,2,1]},"ost.mol":{EntityHandle:[1,3,1],Intersection:[1,1,1],EditorBase:[8,3,1],Union:[1,1,1],ResidueHandle:[1,3,1],EntityView:[1,3,1],XCSEditor:[8,3,1],AtomHandle:[1,3,1],CreateEntity:[1,1,1],Difference:[1,1,1],ChainHandle:[1,3,1],CreateViewFromAtomList:[1,1,1],ICSEditor:[8,3,1]},"ost.img.alg.LowpassFilter":{SetLimit:[0,2,1],GetLimit:[0,2,1]},"ost.mol.ResidueHandle":{GetAtomList:[1,2,1],FindAtom:[1,2,1]},GenericPropertyContainer:{GetIntProp:[14,2,1],GetFloatProp:[14,2,1],SetFloatProp:[14,2,1],GetPropAsString:[14,2,1],SetBoolProp:[14,2,1],SetStringProp:[14,2,1],GetBoolProp:[14,2,1],ClearProps:[14,2,1],HasProp:[14,2,1],GetStringProp:[14,2,1],SetIntProp:[14,2,1]},"ost.img.alg":{LowpassFilter:[0,3,1],HighpassFilter:[0,3,1],GaussianFilter:[0,3,1],FFT:[0,3,1]},"ost.img":{alg:[0,0,0]},"ost.geom.Ellipse2":{SetA:[3,2,1],SetB:[3,2,1],GetArea:[3,2,1],GetA:[3,2,1],GetB:[3,2,1],GetOrigin:[3,2,1],AtAngle:[3,2,1],SetGamma:[3,2,1],At:[3,2,1],GetGamma:[3,2,1],GetBoundingBox:[3,2,1],SetOrigin:[3,2,1]},"ost.geom.Vec3":{y:[17,5,1],x:[17,5,1],z:[17,5,1]},"ost.geom.Vec2":{y:[17,5,1],x:[17,5,1]},"ost.geom":{Normalize:[17,1,1],IsOnLine:[3,1,1],Angle:[3,1,1],Transpose:[16,1,1],Invert:[16,1,1],Line3:[3,3,1],Line2:[3,3,1],AlignedCuboid:[3,3,1],AreParallel:[3,1,1],IsInPlane:[3,1,1],Minor:[16,1,1],EulerTransformation:[16,1,1],OrthogonalVector:[16,1,1],IsInSphere:[3,1,1],AxisRotation:[16,1,1],Plane:[3,3,1],IntersectionLine:[3,1,1],CompDivide:[16,1,1],Distance:[3,1,1],Mat4:[16,3,1],Mat2:[16,3,1],Mat3:[16,3,1],Length2:[17,1,1],Det:[16,1,1],Equal:[16,1,1],Cross:[17,1,1],CompMultiply:[16,1,1],Length:[17,1,1],Ellipse2:[3,3,1],Dot:[17,1,1],CuboidAxis:[3,3,1],AreIntersecting:[3,1,1],Circle2:[3,3,1],Cuboid:[3,3,1],IntersectionPoint:[3,1,1],Rectangle2:[3,3,1],Sphere:[3,3,1],Vec4:[17,3,1],Vec2:[17,3,1],Vec3:[17,3,1]},"ost.geom.Vec4":{y:[17,5,1],x:[17,5,1],z:[17,5,1],w:[17,5,1]},"ost.geom.Rectangle2":{SetEnd:[3,2,1],GetStart:[3,2,1],GetHeight:[3,2,1],height:[3,5,1],GetWidth:[3,2,1],width:[3,5,1],SetStart:[3,2,1],GetEnd:[3,2,1]},"ost.seq.AlignmentHandle":{GetSequence:[4,2,1],AttachView:[4,2,1],Cut:[4,2,1],GetPos:[4,2,1],GetLength:[4,2,1],GetResidueIndex:[4,2,1],Replace:[4,2,1],GetSequenceList:[4,2,1],FindSequence:[4,2,1],ShiftRegion:[4,2,1],ToString:[4,2,1],SetSequenceName:[4,2,1],SetSequenceOffset:[4,2,1],GetCount:[4,2,1],Copy:[4,2,1]},"ost.mol.EditorBase":{InsertChain:[8,2,1],AppendResidue:[8,2,1],InsertAtom:[8,2,1]},"ost.seq":{AlignmentFromSequenceList:[4,1,1],CreateAlignment:[4,1,1],CreateSequence:[4,1,1],SequenceHandle:[4,3,1],AlignmentHandle:[4,3,1],SequenceList:[4,3,1]}},terms:{orthogon:16,getattachedview:4,polypeptid:7,setorigin:3,four:[11,17,18,16,13,14,3],prefix:[6,19,20],skeleton:21,whose:[3,9],line2line3plan:3,deviat:9,under:[20,21],suitabl:14,everi:[19,8],"void":21,unkknown:7,clearprop:14,lefthand:16,getpo:[14,4,13],factori:21,vector:[5,3,17,18,16],math:14,initialis:8,direct:[16,21,3,9,8],second:[2,17,1,16,9,20,14,15,4,3],getcomplex:9,"4x4":16,even:[15,19],newclass:21,neg:4,constrast:4,directori:[5,6,19,13,20,21],"new":[5,21,1,16,19,13,7,8,3,4,9],topolog:[5,7,8],errorn:7,widget:11,getcenterofmass:1,never:19,here:[20,19,13,7,21],studio:20,path:[6,19,13,20],compdivid:16,precis:20,gly:8,atom_nam:[1,7,8],fourier:[5,0,9],rbfac:2,intersectionlin:3,total:[19,1],unit:21,dng:[19,9,20,21],dna:10,describ:[20,1,7],would:[9,2,13,20,4,19],call:[6,21,1,19,7,8,15,4],recommend:20,loadalign:4,type:[2,17,16,19,20,14,15,4,9,3],until:8,tmp_dir_nam:13,relat:[10,1],warn:[2,13],getbuild:7,must:[8,1,16,19,7,21],join:[15,13],setup:21,work:[2,10,19,4],setboolprop:14,conceptu:9,imagehandl:[5,0,9],overrid:14,give:[13,7],indic:7,want:[19,7,21],recov:9,end:[21,15,4,8],atom_impl:21,faulti:15,how:[7,6,19,13,20,4],ent:[15,1,7,12],gaussianfilt:[0,9],verifi:7,config:21,updat:[19,8],setreal:9,recogn:[15,12],after:[0,7,8],befor:[19,9,13,21],originin:8,nucleotid:7,parallel:3,averag:[2,1],abcdefghik:4,attempt:7,third:3,setatompo:8,environ:[6,13,20,21],enter:[19,9,20],exclus:8,order:[6,1,16,7,21,3],origin:[3,19,9,1,8],composit:3,getgaplessstr:4,over:[15,19,4,7,12],half_ext:3,becaus:[14,19],affect:[15,4,9],genericprop:14,gentl:[5,19],ligand:[1,7],fit:[14,4],better:20,chainview:14,them:[14,0,19,20,7],thei:[2,0,17,19,7,14,15,3],fragment:[14,19],rectangl:3,"break":7,intersectionpoint:3,accommod:21,im3:9,im2:9,each:[6,2,21,14,15,4],side:16,bond:[14,19,1,7,8],libost_gmod:21,macromolecul:1,inexist:[15,4],cartographi:19,extract:[5,9,16],network:[19,8],goe:[21,7,8],newli:1,content:21,isinplan:3,linear:1,free:[3,17,8],standard:[21,9,20,7,17],freq:0,angl:[3,16,1,8],half_frequ:0,substructur:14,filter:[5,0,19,9],unabl:6,onto:3,rang:[2,19,7],independ:[9,21],thereof:15,restrict:19,hook:7,alreadi:[14,19,20,8],wrapper:[5,21],wasn:20,addallinclusivebond:19,getpixelsampl:19,top:[3,9,16],sometim:19,conceput:19,master:4,too:4,similarli:19,consol:[9,21],gethalfext:3,namespac:21,tool:20,openstructur:[2,5,11,19,13,20,21,14,9],conserv:14,clustalw:12,provid:[6,15,19,4,9],tree:21,zero:[16,17,7,8],project:[5,3,20,21],matter:15,length2:17,getprop:13,mini:19,chain_nam:[4,1,8],alignedcuboid:3,increment:8,seen:19,fasta:[15,4,12],latter:14,enable_ui:20,though:19,restrict_chain:15,object:[5,0,18,19,3,9],letter:8,abcdhik:4,don:19,doc:19,doe:[2,14,9,1,7],dummi:7,dox:9,declar:21,sum:1,dot:17,api:[5,21,14],visitor:1,"__str__":4,random:9,radiu:[3,13,1,7,8],syntax:[14,2],involv:8,layout:21,menu:20,occ:2,configur:[5,20],folder:19,rnum:[2,19],myfloatprop:14,likewis:7,toolbox:19,bat:19,"public":21,twice:3,mkdtemp:13,commandlin:20,axis_a:3,axis_b:3,axis_c:3,guessatomel:7,mandatori:4,result:[1,16,19,8,14,9],fail:[6,15,1],createent:1,best:4,connectal:7,awar:[0,19],said:9,databas:7,figur:20,clustal:[15,12],awai:3,accord:8,extend:[5,2,7,21],auto_ptr:21,extens:[11,9,15,12],extent:[3,9],ost_mod_unit_test:21,behaviour:[15,20,7],easi:19,howev:[20,9,13,7,8],against:15,fna:12,logic:[9,7],unk:7,col:4,loader:7,getcenterofatom:1,enable_gfx:20,assum:[19,21],editmod:1,union:1,three:[11,18,16,19,21,3],been:[0,9,7,14,15,4],interest:19,basic:[10,17,19,13,7,8,9],"__len__":4,argument:2,qt_qmake_execut:20,dllexport_ost_mod:21,ident:[1,16],properti:[5,10,2,7,8,14,4],aim:19,calcul:[1,2,13,8,14,3],submatrix:16,calpha_onli:15,sever:[21,15,19,4,8],perform:[2,1,7],suggest:7,make:[7,8,19,20,21,9],complex:9,split:[15,4],complet:[15,19,13,7,21],boost_test_cas:21,hand:[3,19,9],getnorm:3,rais:[17,6,1,13,8,14,3,4,15],aka:19,thu:20,inherit:8,client:[20,7],acid:[19,7],thi:[2,5,20,17,6,21,1,16,19,13,7,8,14,3,4,9,15],endif:21,gzip:12,everyth:13,left:[3,19,4,9,16],insertaltatom:8,identifi:[9,1,7],just:[19,4,7],no_hetatm:15,unbuff:8,yet:[1,7],languag:[2,5,19,10],previous:14,extracttransl:16,expos:7,had:19,eigen2:20,els:21,save:[5,15,19,4],boost_root:20,opt:[13,20],applic:19,rna:10,background:9,apart:2,measur:3,resnum:19,specif:[13,7],arbitrari:[14,16],manual:[5,19,1,20,13],zoom:19,getgamma:3,underli:[19,9],right:[3,4],deal:[10,15,19,7],negat:[2,17,16],interv:4,loadsequencelist:4,intern:[10,1,7,8],txt:21,bottom:[3,19],settransform:8,getsequenceoffset:4,subclass:7,multipli:[17,16],sequencehandl:[5,4,14],setcomplex:9,core:[19,20],plu:[21,8],promod:12,buri:7,fft_imag:0,getpropasstr:14,repositori:20,areintersect:3,slightli:[14,2],surround:14,done:[2,13],produc:4,isresiduecomplet:7,"float":[14,3,2,17],bound:[3,1],down:16,wrap:15,createsequencelist:4,accordingli:9,wai:[2,6,19,7,15,9],support:[2,17,12,16,19,20,8,14,15,4],transform:[5,0,9,8],why:[6,19],avail:[17,12,19,13,20,21,14,3,4,9,15],width:[3,4,9],reli:[7,8],editor:[5,10,1,8],head:19,creation:[9,1],infom:8,form:[1,2,7,21,3,19],offer:[15,9,20],forc:19,epsilon:[3,16],hear:19,"true":[6,16,2,13,20,14,3,4,15],maximum:[3,9],tell:20,fundament:19,applyip:[0,9],adopt:7,arbitrarili:3,exist:[2,1,9,8,14,4,19],check:[5,20,6,13,7,21,14,3,15],calpha:15,when:[2,17,6,21,1,16,9,20,8,14,3,4,15],test:[5,21],tif:9,mapiso:19,consid:[2,7],omega:7,fsa:12,furthermor:9,top_left:3,geometr:[5,3,18],time:[21,19,9,7,8],getcount:4,ost_mol:21,concept:19,chain:[2,1,19,7,8,14,15,4],global:[21,8],ost:[5,0,20,17,6,21,1,16,19,13,7,8,3,4,9,15],unit_test:21,view_b:1,dalton:1,row:[4,16],middl:19,depend:[5,21,19,13,20,8,14,15],graph:8,getmean:9,certainli:19,vec:[17,16],sourc:[5,20,7,21],string:[2,14,15,4],feasibl:7,atom_a:7,atom_b:7,word:19,exact:[20,15,1,7],rectangle2:3,level:[14,2,7,21],gui:[5,11,19,9],fftw:20,iter:4,dir:3,upper:3,map_filt:19,sign:3,corner:[3,9,16],appear:[15,7],current:[2,19,9],boost:[14,20,21],deriv:14,gener:[2,5,10,1,16,19,13,20,14,15,9],water:1,address:14,along:[3,19],wait:19,box:1,shift:[19,4],tweak:15,modul:[5,20,10,21,1,18,16,19,13,7,8,3,4,9,15],prefer:[6,5],leav:[3,9],instal:[5,19,20,21],updatexc:8,rindex:2,chainhandl:[14,1,8],msm:13,scope:8,prev:7,checkout:20,stderr_valu:13,ioexcept:15,visual:[5,19,9,20],examin:19,graphic:[5,11,19,9,20],prepar:[5,13],uniqu:8,can:[2,20,6,21,19,13,7,8,14,3,4,9,15],completeatom:7,purpos:[19,21],problemat:7,heart:10,hydrogen:7,occup:2,alwai:[14,3,19,9,8],multipl:[20,16],complex_spati:0,endmdl:15,write:[5,9,2,13,21,3,19],map:[5,19,20,14,15,4,9],product:[17,16],mat:16,max:3,pqr:12,pending_xref:[3,15,1,8],mai:[2,19,7],data:[5,10,19,21,14,4,9],axisrot:16,fghik:4,predic:[2,19],inform:[6,19,7,8,4,9],"switch":7,setgamma:3,combin:[2,19,1,16],block:14,isbondfeas:7,microscop:19,still:[6,13],mainli:[20,1,7],dynam:19,entiti:[2,5,10,1,19,13,8,14,15,4],group:[19,21],getwidth:3,platform:[19,20,21],window:[11,19,9,20,21],main:[11,19,7,21],non:[4,9,1],initi:[16,17,8],half:[3,4],now:[19,4,9,20],halo:19,introduct:[5,9,2,13,14,19],name:[2,6,21,1,12,19,13,7,8,14,15,4],invalidalign:4,drop:8,addbond:19,separ:[15,7],compil:[20,21],domain:[0,9],replac:[19,4],gaussian:[0,9],happen:[21,16,8],shown:[13,7,17],space:[5,0,9,3,8],findchain:1,module_config:21,tmp_file_nam:13,correct:[7,21],dataset:[10,19],seq_str:4,argv:21,ori:3,org:7,argc:21,card:12,care:[2,19,21],getsequencelist:4,suffici:19,frequenc:[0,9],setfloatprop:[14,2],entityview:[10,19,4,1,14],turn:1,place:[19,9,21],principl:[13,8],imposs:7,qmake_execut:6,first:[0,17,6,21,1,16,19,13,7,8,14,3,4,9,15],oper:[2,10,0,17,1,18,16,19,8,3,4,9],directli:[17,6,13,7,8,3],onc:[1,20],biozentrum:20,yourself:19,fast:[0,4],bondhandl:14,open:[9,13],size:[0,9],given:[2,0,1,16,9,7,8,14,3,4],vec3line3:3,silent:17,paramt:3,breez:19,circl:3,white:9,conveni:[2,14,19,13],includ:[8,2,13,21,4,19],especi:13,copi:[21,4,1,17],getheight:3,specifi:[7,2,20,14,4,19],pyqt4:20,assignbackbonetorsionstoresidu:7,than:[0,2,3,7,16],png:19,wide:19,d03:16,d02:16,d01:16,d00:16,isinspher:3,ost_mod_test_modeling_h:21,blabla:2,posit:[2,4,1,13,8],pre:[10,0,6,11,18,9,7,15,4],sai:[6,15],ost_module_ost_mod:21,ani:[2,1,19,7,21,14,3,9],refexplicit:[3,15,1,8],setsequencenam:4,squar:17,advic:8,moreov:9,note:[1,2,21,14,4,9],take:[2,9,20,21],green:19,begin:4,sure:[9,20,7,8],trace:7,normal:[21,3,17,16],buffer:8,beta:19,unit_test_framework:21,pair:[14,15],icon:21,later:[9,21],geomexcept:3,axi:[3,19,1,16],sigma:[0,9],cmakelist:21,show:[19,4,9],ost_mod:21,subprocess:13,threshold:[3,7],frontend:9,requesticseditor:1,help:[19,4],onli:[2,1,16,19,7,21,3,4,9,15],explicitli:[15,8],getresidueindex:4,activ:9,written:[19,9,13,21],parametr:3,black:9,helix:2,offici:19,overwritten:14,atom_list:1,variou:[4,7],get:[5,6,1,16,19,14,3,4],tailor:1,theta:16,getatomlist:[14,1,13],fault_toler:15,requir:[20,1,9,7,21,15,4,3],yield:9,whera:3,through:[2,19,9],python_root:20,where:[6,19,13,20,21,9],centrosymmetr:9,hetatm:[15,7],detect:[15,12],kei:[14,19,7],enough:[19,20],jth:16,between:[2,3,4,1,7],"import":[12,19,13,7,21,14,15,9],parent:[19,8],tut:19,connectresiduetoprev:7,come:19,img:[5,0,19,9],region:[4,9],tutori:[2,5,19,13],mani:[15,9,21],setintprop:[14,2],atom_handl:[2,21],pop:9,featur:[19,7],colon:2,amino:[19,7],invert:16,compound_lib:7,invers:[16,4,8],mark:21,getgeometriccent:1,createviewfromatomlist:1,complicatedpred:1,thousand:7,resolut:19,testpropr:2,ost_mol_alg:21,"case":[20,21,16,19,13,7,8,3,4,9,15],prefix_:6,tostr:4,rtype:2,untransform:8,invok:[20,7,21],planar:9,wwpdb:7,getlastnongap:4,stdout:13,henc:1,everydai:19,abcdefghiklmnop:4,protein:[5,15,19,4,10],"__init__":21,develop:[19,20,21],d11:16,d12:16,d13:16,same:[2,21,1,16,19,7,8,14,3,4,9,15],binari:[6,19,13,20],html:19,insertchain:8,document:[5,20,1,19,7,14,4],createfullview:1,finish:8,screenshot:19,capabl:9,extern:[5,10,8,1,13,21],tradition:7,conop:[5,7,8],macro:21,iupac:[7,8],ostrc:6,without:[15,19,4,7],model:[15,19,21],dimension:19,execut:[5,0,6,1,19,13,21],aspect:7,hint:[6,13],returncod:13,littl:9,versa:[4,9,8],testpropchain:2,seq_index:4,earli:19,psi:7,around:[19,16],read:[5,19,13,7,3,9],temperatur:2,mol:[5,10,21,1,19,8,15],mod:21,either:[1,19,7,21,3,9],output:[5,19,13,14,15,4],inter:7,getsequ:4,intact:19,abs_qmake_path:6,slice:19,subpart:[19,4,1],getvalu:6,definit:21,edit_mod:1,chemdict_tool:7,visualstudio:20,lowpassfilt:[0,19],atomprop:8,power:2,inspect:[5,19],atomhandlelistatomviewlist:1,fulli:9,"throw":[14,2],sel_a:2,sel_c:2,dividebyzeroexcept:17,sel_r:2,stand:17,"2x2":16,mol_alg:21,routin:21,effici:9,getchainlist:1,gatestpropatom:2,your:[3,19,15,20],buffered_edit:1,area:[3,9,11],connectresiduetonext:7,use_shad:20,start:[1,2,8,14,4,19],interfac:[5,11,20,1,19,7,8,4,9],strictli:7,test_suit:21,dirti:19,possibl:[2,4,21],"default":[20,6,2,7,8,14,4],output_dir:21,expect:2,rname:[2,19],creat:[5,1,16,19,7,21,3,4,9],certain:[2,20,7],deep:[4,1],residue_nam:8,file:[5,6,12,19,13,7,21,15,4],explicit_file_nam:6,fill:[9,7],again:[19,4],getorigin:3,imgdataview:19,valid:[4,1,7,8],xcseditor:[1,8],spatial:[0,9,8],ignor:[15,7],you:[2,20,1,19,13,7,3,4,9,15],refdomain:[3,15,1,8],registri:7,sequenc:[5,12,19,14,15,4],symbol:21,vertex:13,track:9,d21:16,d20:16,d23:16,d22:16,mask:0,mass:1,cpp:21,dssp:2,aln:[4,12],represent:[14,19],all:[2,5,20,21,1,16,19,13,7,8,14,4,9],forget:19,ali:12,illustr:[19,4,16],alg:[5,0,19,9,21],forbidden:4,scalar:[17,16],follow:[2,0,17,21,12,16,19,13,8,14,4,9],disk:[15,4],imagenam:9,residue_index:4,setcent:3,libost_mod:21,init:21,program:[5,20,13,7],getmin:3,setstart:3,introduc:7,liter:[10,0,6,1,18,11,9,7,8,3,4,15],far:[19,7],print:[17,16,19,13,14,4],fall:4,veri:[14,19,9,13],list:[6,1,19,21,15,4],adjust:[4,9],small:10,anam:[2,15,19],gctestpropchain:2,dimens:[17,18,16,19,20,3],crystallographi:19,sync:9,past:[5,9],biolog:1,design:[11,19,4],pass:[0,3,20],further:[3,2],what:[6,5,19,20,16],abc:4,section:19,abl:1,"__init":21,overload:[17,7,16],delet:[4,7],abbrevi:[10,2],version:[17,8,19,20,21,4],intersect:[3,1],consecut:7,deepli:19,method:[2,0,21,1,19,7,8,14,3,4,9],essenc:[14,4],ost_mod_module_config_hh:21,full:[6,1,19,13,20,15],vec_b:17,shouldn:1,vec_a:17,trunk:20,modifi:[9,7],valu:[2,17,6,16,19,20,14,3,9],search:[6,13,20],popen:13,amount:4,magnitud:3,quotient:16,via:[16,12,17,20,8],shorthand:4,filenam:15,heurist:7,decrement:8,establish:7,select:[2,15,19,4,1],regist:7,two:[2,20,17,1,18,16,19,7,8,3,4,9],minor:16,more:[2,11,1,19,7,14,15,4],chain_handl:2,flag:[20,1,7],hetorogen:2,particular:19,attached_view:4,none:[6,20],der:[7,8],det:16,learn:19,motiv:[5,7],getcircumfer:3,def:[4,21],prompt:20,ost_mod_pymod_sourc:21,integrityerror:[4,1,8],share:[19,21],sphere:[3,1],minimum:[3,9],cours:19,join_spread_atom_record:15,divid:[11,17,16],rather:[19,1,8],anoth:[14,9,7],getmass:1,reject:7,simpl:[15,21],resourc:8,variant:14,reflect:14,plane:[3,19],charmm:[15,12],d10:16,search_system_path:[6,13],"short":[19,20],invalidsequ:4,deepview:19,queryflag:1,rotat:[19,16],ith:16,fft:[0,9],soon:9,reftyp:[3,15,1,8],vec4:17,circumfer:3,vec2:[3,17],vec3:[3,16,1,17,8],hierarchi:19,loadimag:[19,9],paramet:[17,1,16,7,8,3,4,15],getx:14,d32:16,d33:16,d30:16,d31:16,pend:[1,8],might:20,boost_test_suit:21,"return":[0,17,6,21,1,16,9,7,8,14,3,4,15],framework:[5,19,4,7,21],compound:7,bigger:3,neccessari:19,queryerror:1,easili:7,achiev:[19,4,7],radian:[3,16],ceas:9,found:[7,6,1,19,13,20,21],tmp_file_handl:13,gfx:19,lysin:19,weight:1,hard:7,realli:9,connect:[5,19,7,8],energi:14,orient:3,getintprop:14,setdefaultbuild:7,ost_mod_head:21,vliet:0,test_model:21,file_nam:6,guess:[15,7],reason:6,base:[21,1,2,7,8,15,4],put:[21,8],teach:21,thrown:14,setlimit:0,assign:7,major:[19,16],getfirstnongap:4,prevent:1,dino:19,number:[2,21,1,9,13,7,8,4,19],connectresiduewithnext:7,dylib:21,atom_count:19,miss:7,stage:21,differ:[2,1,16,19,7,21,14,3],script:[19,7,21],interact:[14,19,9],cuboidaxi:3,construct:[5,3,19],createimag:[0,9],statement:[2,21,19,8],fftw3:20,store:[5,16,19,14,3,9],option:[15,20,7],wrap_mod:21,part:[2,11,1,9,7,21,4,19],getboolprop:14,applytransform:8,center:[3,19,1],std:21,kind:[4,20],molecular:[5,10,1,13,7,15],whenev:[7,8],remov:[14,16,4,8],aah:19,pasterot:16,toward:3,comput:9,hasattachedview:4,packag:20,areparallel:3,dedic:[15,19],lie:10,xref:[3,15,1,8],built:[20,21],genericpropertycontain:14,createemptyview:[19,1],click:19,also:[2,10,20,6,21,1,19,13,7,8,14,3,4,9],build:[5,21,20,14,8],pipelin:7,testprop:2,previou:[19,7],most:[11,21,19,20,8,14,15],plan:20,maco:[19,21],alpha:[15,19],charg:8,getradiu:3,exc:3,chain_count:19,cover:[5,19,4],clean:[9,7],brookhaven:[19,12],latest:7,think:19,alphanumer:4,setselect:19,"3x3":16,fine:[9,7,12],find:[7,6,1,19,20,4],impact:19,access:[2,5,4,1,14],indexerror:4,pretti:19,setnam:4,solut:20,factor:2,express:2,nativ:21,loadpdb:[15,19,12],treshold:3,hik:4,alignedregionalignmenthandl:4,residuehandl:[14,1,8],oxt:7,common:[15,19,4],crd:12,seamlessli:21,set:[2,5,0,20,17,6,21,16,19,13,7,8,14,3,4,9,15],seq:[5,4],unknownprop:14,see:[2,1,19,7,8,14,3,9,15],close:[4,13],sel:[2,19],contour:19,particip:7,won:19,libpng:20,altern:[1,8],signatur:[14,3,4,16],syntact:1,numer:[2,14,9],distinguish:7,popul:[1,21],both:[1,19,7,21,14,9],last:[21,19,4,13,8],getresiduelist:1,extractrot:16,doespeptidebondexist:7,context:21,py__:21,mean:[21,16,9,7,8,14,3,4],pdb:[15,19,7,12],load:[5,12,19,13,7,15,4,9],conopoloi:7,circle2:3,conopolog:7,getdirect:3,except:[6,14,4,13,16],residu:[2,1,19,7,8,14,15,4],header:[20,21],param:16,suppli:[0,15],throughout:21,rulebasedbuild:7,vertic:13,sequence_offset:4,iounknownformatexcept:15,empti:[14,15,4,9,1],sinc:[2,19,9],line2line3:3,acefghiklmnpqrstuvwi:4,fire:19,refdoc:[3,15,1,8],imag:[5,0,19,20,21,15,9],great:7,gap:4,coordin:[2,10,17,1,19,7,8,3,9],understand:9,ishetatm:2,rai:19,look:[16,19,13,7,21,4,9],straight:19,erron:15,"while":[21,9,7,8],abov:[19,13,20],error:[6,1,2,13,14,4],real:[14,21,9,17,16],readi:[5,19],connectatomsofresidu:7,chemlib:7,itself:21,righthand:16,minim:3,belong:[15,19,7],val_default:6,higher:[0,19],optim:20,getvector:3,temporari:[9,13],user:[5,11,7,6,19,20],loadsequ:4,implement:[10,0,17,21,1,7,8],stateless:9,lower:[0,19,3],task:[13,7],equival:[9,20],pymod:21,ost_mod_sourc:21,centeron:19,explan:19,boost_python_modul:21,cuboid:3,load_multi:15,findwithin:1,cut:4,shortcut:19,getcent:3,input:[5,15,19,4],subsequ:7,euler:16,bin:[19,20,21],format:[6,12,19,7,15,4],big:11,molecul:[5,19,1,7,10],intuit:11,backbon:[19,7],im_ft:9,success:13,docutil:[10,0,6,11,18,9,7,15,4],signal:0,collect:1,princip:3,ost_mod_new_class_h:21,encount:[1,7],often:[2,13,7,14,4,19],dllimport:21,duck:19,some:[7,19,13,20,15,9],back:[0,9,7],sampl:[19,9],checkresiduecomplet:7,surpris:4,findbondtoatom:19,euclidian:8,view_a:1,per:19,prop:[2,8],proc:13,machin:20,resid_handl:2,run:[7,2,13,20,21,9],step:[19,9,13,20,21],subtract:[17,16],"_mod":21,transpos:16,shini:[5,19],getext:[3,9],gamma:3,within:[2,5,9,13,20],stdout_valu:13,ensur:3,chang:[1,9,7,8,4,19],span:[10,0,6,11,18,9,7,15,4],"long":19,custom:[5,15,2,7,14],isosurfac:19,arithmet:[17,16],plane1:3,plane2:3,suit:21,forward:[19,4],getreal:9,properli:8,sdf:[15,12],link:[2,7,21],translat:16,atom:[2,5,1,19,13,7,8,14,15],line:[1,19,13,7,21,14,3,4,9],cif:[5,7],consist:[2,19,4,13,21],testpropatom:2,highlight:[2,19],similar:19,impl:21,saveent:15,new_region:4,repres:[10,3,4,1,16],"char":21,gapless_str:4,incomplet:7,guarante:3,setend:3,cmake:[20,21],sequenti:15,invalid:[4,1,7],angstrom:2,filenotfound:[6,13],draw:19,getarea:3,constsequencelist:4,meaning:16,amplitud:9,svn:20,algorithm:[5,0,1,19,7,8,9],vice:[4,9,8],code:[5,20,21,16,2,7,8,19],queri:[5,10,1,2,14,19],getvertexidlist:13,ellips:3,iplt:19,young:0,sens:9,mous:19,electron:[14,19],shiftregion:4,volum:19,untouch:[3,9],implicitli:9,relev:21,tri:6,"try":[14,4],dealt:19,refer:[10,8,2,7,21,19],setoriginalatompo:8,pleas:[2,19,20],impli:20,smaller:[11,4,16],visualis:[19,7],natur:[19,9],focu:2,download:[20,7],tortoisesvn:20,getstringprop:14,append:8,index:[2,4],compar:16,createmodelingtest:21,createsequ:4,loadsequencefromstr:4,createalign:4,findatom:[19,1],highpassfilt:0,len:13,let:[5,6,19,20,21,9],becom:[19,7,21],implicit:3,convert:[5,0,9,7],shader:20,typic:[19,4,21],honor:[2,9],abcd:4,isonlin:3,appli:[5,0,1,19,7,8,9],app:[19,13],"boolean":[2,10,19,1],createemtpyview:1,subimag:9,from:[2,20,21,1,16,19,13,7,8,14,3,4,9,15],commun:13,doubl:19,next:[6,19,20,21],websit:19,few:14,camera:19,hasprop:14,findresidu:1,"1ppt":19,findsequ:4,src:21,getlimit:0,grtestpropr:2,retriev:[6,5,14],cumbersom:19,obvious:[9,21],ghiklm:4,control:[15,20,7,12],process:[5,0,20,19,13,7,9],reftarget:[3,15,1,8],high:7,opensourc:20,in_dir:21,sequencelist:[5,4],delai:8,surfac:[5,13,10],sip:20,line3:3,line2:3,line1:3,infeas:7,subdirectori:21,instead:[15,2,7],sin:14,entityhandl:[10,15,19,1,14],class_:21,enable_img:20,alloc:8,essenti:17,boost_check:21,counter:8,correspond:21,element:[2,16,7,8],allow:[2,19,15,4,9,3],getboundingbox:3,depends_on:21,move:19,unit_unit_test_suit:21,onmissingatom:7,bunch:20,ost_unittest:21,chosen:7,therefor:[2,14,19],pixel:[0,9],vec2vec3vec4:16,icseditor:[1,8],python:[5,20,21,1,19,13,7,8,14,9],auto:15,handi:13,registerbuild:7,mention:20,qmake:[6,20],terminu:[1,7],anyth:4,edit:[10,1,8],mode:[10,8],gatestprop:2,subset:1,attachview:4,"static":16,our:[19,7],dependeci:20,out:[5,0,20,9,13,7,8],variabl:[6,19,9,13],matrix:[18,16],influenc:[4,20],waal:[7,8],geom:[5,17,1,18,16,8,3],clockwis:16,"100208_openstructure_ui_color":[],matric:[5,16,18,8],statist:9,insid:[14,19],addsequ:4,manipul:[5,19,9,8],dictionari:[5,7],releas:21,mat4:[16,8],mat2:16,mat3:16,could:[6,2,1,13],keep:9,length:[17,1,16,8,3,4],cname:[15,2],entityhandleentityview:15,softwar:7,scene:19,residue_count:19,lib:[20,21],suffic:9,unknown:7,system:[10,21,1,2,20,8,3,19],messag:[6,4],fragment_map:19,attach:[5,4],termin:19,"final":21,shell:[19,13,20],getlength:4,editorbas:8,onunknownatom:7,orthogonalvector:16,haven:[15,20],mat2mat3mat4:16,getfloatprop:14,bother:1,structur:[2,5,10,21,1,12,19,7,8,15,4],charact:[2,4],residueview:14,viewer:9,linker:21,have:[2,20,19,7,21,14,3,4,9,15],tabl:7,need:[2,14,9,20,21],res_num:[1,8],min:3,mid:1,mix:19,rand_alg:9,which:[2,10,11,1,9,21,14,15,4],singl:[2,4,1,20],unless:2,bottom_right:3,loadsurfac:13,"class":[2,10,0,17,6,21,1,18,16,11,19,7,8,14,3,4,9,15],homogen:17,url:20,boost_fail:21,request:[4,9,1,8],pipe:13,determin:[9,16],dllexport:21,insertatom:8,filetyp:15,unbuffered_edit:1,anywai:19,eulertransform:16,locat:[5,6,19,13,20,8],should:[20,7,21],suppos:7,discontinu:7,flexibl:11,familiar:19,autom:7,rumbl:[5,19],atomhandl:[14,2,1,8],enabl:20,organ:[11,8],addatom:[19,1],integr:2,contain:[11,20,6,1,18,19,7,21,14,3,4,9,15],view:[2,5,1,19,14,15,4],nitrogen:7,newmethod:21,frame:9,genericproperror:14,target_link_librari:21,val_kei:6,res_index:4,closer:7,correctli:9,createdataview:[19,9],state:[19,9],chemic:7,freg_limit:0,tempfil:13,job:[19,20],entityvisitor:1,addit:[19,4,9,7,21],revers:4,plugin:15,getstart:3,equal:[19,4,16],etc:[9,21],instanc:[4,9,7],grain:[7,12],equat:3,swallow:17,ca_cb:19,guidelin:21,hyphen:4,walk:19,respect:[14,2,17],torsion:[1,7],quit:21,heuristicbuild:7,requestxcseditor:1,compon:[7,16],alignmenthandl:[5,4,14],treat:7,trajectori:15,calledprocesserror:13,atomview:14,togeth:[3,4],present:[6,15,9,7],replic:21,multi:[15,20],align:[5,1,19,15,4,3],defin:[20,6,21,16,2,7,8,14,3],rbb:7,helper:[6,13],almost:19,site:7,genericpropcontain:14,default_valu:14,biologi:4,partner:19,geta:3,getb:3,dataview:19,savepdb:[15,19],cross:[3,17],member:9,handl:[1,2,8,14,15,19],ifndef:21,phi:[7,16],http:20,upon:8,exot:15,decoupl:9,tighter:15,off:20,unitest:21,setb:3,builder:[5,7,8],well:[9,7,8],thought:7,exampl:[17,16,19,13,7,21,14,15,4,9],command:[21,19,4,9,13],choos:[20,8],undefin:[16,8],usual:[19,1,21],compmultipli:16,distanc:[3,2,7],loadent:[15,7,12],obtain:[14,13],exe_path:13,point:[9,1,2,13,20,3,19],add:[21,19,7,8],densiti:[5,19,9,20,14],getmax:3,bool:[14,3,2],angstroem:19,match:[19,1],uniba:20,five:2,know:[6,4,9],realis:19,height:[3,9],recurs:0,insert:[4,7,8],like:[7,19,13,20,21,4],lost:9,necessari:[9,13,7,21],page:21,setradiu:3,linux:[19,21],modeling_new_class:21,"export":[15,21],smoothli:2,proper:[7,8],home:13,librari:[19,20,7,21],lead:21,avoid:9,env_nam:[6,13],entityvisitori:1,overlap:9,freq_limit:0,overlai:19,duplic:1,getnam:4,imaginari:9,usag:[5,0],noisi:9,appendresidu:8,offset:[3,4],panel:[11,19],about:9,actual:[9,21],column:[4,16],constructor:3,fals:[1,2,7,8,14,3,4,15],disabl:20,own:3,libtiff:20,abfac:2,automat:[15,9],due:[15,19,1,21],setstringprop:14,destructor:8,van:[0,7,8],val:[14,9],pictur:19,fragment_map_filt:19,inner:9,"function":[10,17,6,21,1,18,12,16,9,13,20,8,15,4,19],compoundlib:7,atangl:3,setsequenceoffset:4,buildrawmodel:7,search_path:[6,13],continu:15,getend:3,count:8,succe:15,made:[1,21],wise:16,temp:13,whether:[3,2,20,7],displai:[5,19],record:15,below:[2,3,4,9],limit:[0,21],otherwis:[6,15,4,1,16],"int":[14,21,2,17],descript:[6,20,19,13,7],dure:[19,7],meaningless:8,pir:12,sys_root:20,probabl:19,mutual:8,hpp:21,detail:[6,1,19,13,14,4],riaa:8,other:[10,1,18,9,7,21,4,19],identifyresidu:7,stat:9,repeat:9,seta:3,add_subdirectori:21,singleton:7,peptid:[2,15,19,1,7],alignmentfromsequencelist:4,reliabl:7,rule:[21,0,19,7,8],getp:3,ellipse2:3},objtypes:{"0":"py:module","1":"py:function","2":"py:method","3":"py:class","4":"py:staticmethod","5":"py:attribute","6":"py:exception"},titles:["<tt class=\"docutils literal docutils literal\"><span class=\"pre\">alg</span></tt> - Image Processing Algorithms","The Molecular Entity","Queries","Geometric Objects","<tt class=\"docutils literal docutils literal docutils literal\"><span class=\"pre\">seq</span></tt> – Sequences and Alignments","OpenStructure documentation","<tt class=\"docutils literal\"><span class=\"pre\">ost.settings</span></tt> - Locate Files and Retrieve Preferences","<tt class=\"docutils literal\"><span class=\"pre\">conop</span></tt> – Connectivity and Topology of Molecules","Editors","<tt class=\"docutils literal docutils literal docutils literal\"><span class=\"pre\">img</span></tt> Images and Density Maps","<tt class=\"docutils literal docutils literal docutils literal docutils literal docutils literal\"><span class=\"pre\">mol</span></tt> – Molecular structures and surfaces","<tt class=\"docutils literal\"><span class=\"pre\">gui</span></tt> – Graphical User Interface","Supported File Formats","Using External Programs within OpenStructure","Storing Custom Data","<tt class=\"docutils literal docutils literal\"><span class=\"pre\">io</span></tt> - Input and Output of Sequences, Structures and Maps","Matrices","Vectors","<tt class=\"docutils literal docutils literal\"><span class=\"pre\">geom</span></tt> – vectors, matrices and geometrical objects","A gentle introduction to OpenStructure","Installing OpenStructure","Creating a New Module"],objnames:{"0":"Python module","1":"Python function","2":"Python method","3":"Python class","4":"Python static method","5":"Python attribute","6":"Python exception"},filenames:["img/alg/alg","mol/base/entity","mol/base/query","geom/composite","seq/base/seq","index","base/base","conop/conop","mol/base/editors","img/base/img","mol/base/mol","gui/gui","io/formats","external","base/generic","io/io","geom/mat","geom/vec","geom/geom","intro","install","newmodule"]})
\ No newline at end of file
diff --git a/doc/build/seq/base/seq.html b/doc/build/seq/base/seq.html
deleted file mode 100644
index b2fc47f98c7d4e0c65f7f79e4739465fd53653d7..0000000000000000000000000000000000000000
--- a/doc/build/seq/base/seq.html
+++ /dev/null
@@ -1,552 +0,0 @@
-
-
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
- <head>
- <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-
- <title>seq – Sequences and Alignments — OpenStructure v1.0 documentation</title>
- <link rel="stylesheet" href="../../_static/sphinxdoc.css" type="text/css" />
- <link rel="stylesheet" href="../../_static/pygments.css" type="text/css" />
- <script type="text/javascript">
- var DOCUMENTATION_OPTIONS = {
- URL_ROOT: '../../',
- VERSION: '1.0',
- COLLAPSE_INDEX: false,
- FILE_SUFFIX: '.html',
- HAS_SOURCE: true
- };
- </script>
- <script type="text/javascript" src="../../_static/jquery.js"></script>
- <script type="text/javascript" src="../../_static/underscore.js"></script>
- <script type="text/javascript" src="../../_static/doctools.js"></script>
- <link rel="top" title="OpenStructure v1.0 documentation" href="../../index.html" />
- <link rel="next" title="ost.settings - Locate Files and Retrieve Preferences" href="../../base/base.html" />
- <link rel="prev" title="Queries" href="../../mol/base/query.html" />
- </head>
- <body>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- accesskey="I">index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../../base/base.html" title="ost.settings - Locate Files and Retrieve Preferences"
- accesskey="N">next</a> |</li>
- <li class="right" >
- <a href="../../mol/base/query.html" title="Queries"
- accesskey="P">previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="sphinxsidebar">
- <div class="sphinxsidebarwrapper">
- <h3><a href="../../index.html">Table Of Contents</a></h3>
- <ul>
-<li><a class="reference internal" href="#"><tt class="docutils literal"><span class="pre">seq</span></tt> – Sequences and Alignments</a><ul>
-<li><a class="reference internal" href="#attaching-structures-to-sequences">Attaching Structures to Sequences</a><ul>
-<li><a class="reference internal" href="#sequence-offset">Sequence Offset</a></li>
-</ul>
-</li>
-<li><a class="reference internal" href="#loading-and-saving-sequences-and-alignments">Loading and Saving Sequences and Alignments</a></li>
-<li><a class="reference internal" href="#the-sequencehandle">The SequenceHandle</a></li>
-<li><a class="reference internal" href="#the-sequencelist">The SequenceList</a></li>
-<li><a class="reference internal" href="#the-alignmenthandle">The AlignmentHandle</a></li>
-</ul>
-</li>
-</ul>
-
- <h4>Previous topic</h4>
- <p class="topless"><a href="../../mol/base/query.html"
- title="previous chapter">Queries</a></p>
- <h4>Next topic</h4>
- <p class="topless"><a href="../../base/base.html"
- title="next chapter"><tt class="docutils literal docutils literal docutils literal"><span class="pre">ost.settings</span></tt> - Locate Files and Retrieve Preferences</a></p>
- <h3>This Page</h3>
- <ul class="this-page-menu">
- <li><a href="../../_sources/seq/base/seq.txt"
- rel="nofollow">Show Source</a></li>
- </ul>
-<div id="searchbox" style="display: none">
- <h3>Quick search</h3>
- <form class="search" action="../../search.html" method="get">
- <input type="text" name="q" size="18" />
- <input type="submit" value="Go" />
- <input type="hidden" name="check_keywords" value="yes" />
- <input type="hidden" name="area" value="default" />
- </form>
- <p class="searchtip" style="font-size: 90%">
- Enter search terms or a module, class or function name.
- </p>
-</div>
-<script type="text/javascript">$('#searchbox').show(0);</script>
- </div>
- </div>
-
- <div class="document">
- <div class="documentwrapper">
- <div class="bodywrapper">
- <div class="body">
-
- <div class="section" id="module-ost.seq">
-<span id="seq-sequences-and-alignments"></span><h1><a class="reference internal" href="#module-ost.seq" title="Contains classes and functions to deal with sequences and alignments"><tt class="xref py py-mod docutils literal"><span class="pre">seq</span></tt></a> – Sequences and Alignments<a class="headerlink" href="#module-ost.seq" title="Permalink to this headline">¶</a></h1>
-<p>The <tt class="xref py py-mod docutils literal"><span class="pre">seq</span></tt> module helps you working with sequence data of various kinds. It
-has classes for <a class="reference internal" href="#ost.seq.SequenceHandle" title="ost.seq.SequenceHandle"><tt class="xref py py-class docutils literal"><span class="pre">single</span> <span class="pre">sequences</span></tt></a>, <a class="reference internal" href="#ost.seq.SequenceList" title="ost.seq.SequenceList"><tt class="xref py py-class docutils literal"><span class="pre">lists</span> <span class="pre">of</span>
-<span class="pre">sequences</span></tt></a> and <a class="reference internal" href="#ost.seq.AlignmentHandle" title="ost.seq.AlignmentHandle"><tt class="xref py py-class docutils literal"><span class="pre">alignments</span></tt></a> of two or
-more sequences.</p>
-<div class="section" id="attaching-structures-to-sequences">
-<span id="attaching-views"></span><h2>Attaching Structures to Sequences<a class="headerlink" href="#attaching-structures-to-sequences" title="Permalink to this headline">¶</a></h2>
-<p>Being a structural biology framework, it is not surprising that the sequence
-classes have been designed to work together with structural data. Each sequence
-can have an attached <tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt> allowing for fast mapping between
-residues in the entity view and position in the sequence.</p>
-<div class="section" id="sequence-offset">
-<span id="id1"></span><h3>Sequence Offset<a class="headerlink" href="#sequence-offset" title="Permalink to this headline">¶</a></h3>
-<p>When using sequences and structures together, often the start of the structure
-and the beginning of the sequence do not fall together. In the following case,
-the alignment of sequences B and C only covers a subpart of structure A:</p>
-<div class="highlight-python"><pre>A acefghiklmnpqrstuvwy
-B ghiklm
-C 123-45</pre>
-</div>
-<p>We would now like to know which residue in protein A is aligned to which residue
-in sequence C. This is achieved by setting the sequence offset of sequence C to
-4. In essence, the sequence offset influences all the mapping operations from
-position in the sequence to residue index and vice versa. By default, the
-sequence offset is 0.</p>
-</div>
-</div>
-<div class="section" id="loading-and-saving-sequences-and-alignments">
-<h2>Loading and Saving Sequences and Alignments<a class="headerlink" href="#loading-and-saving-sequences-and-alignments" title="Permalink to this headline">¶</a></h2>
-<p>The <tt class="xref py py-mod docutils literal"><span class="pre">io</span></tt> module supports input and output of common sequence formats.
-Single sequences can be loaded from disk with <tt class="xref py py-func docutils literal"><span class="pre">io.LoadSequence()</span></tt>,
-alignments are loaded with <tt class="xref py py-func docutils literal"><span class="pre">io.LoadAlignment()</span></tt> and lists of sequences are loaded with <tt class="xref py py-func docutils literal"><span class="pre">io.LoadSequenceList()</span></tt>. In addition to the file based input
-methods, sequences can also be loaded from a string:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">seq_string</span><span class="o">=</span><span class="s">'''>sequence</span>
-<span class="s">abcdefghiklmnop'''</span>
-<span class="n">s</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadSequenceFromString</span><span class="p">(</span><span class="n">seq_string</span><span class="p">,</span> <span class="s">'fasta'</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">s</span><span class="o">.</span><span class="n">name</span><span class="p">,</span> <span class="n">s</span> <span class="c"># will print "sequence abcdefghiklmnop"</span>
-</pre></div>
-</div>
-<p>Note that, in that case specifying the format is mandatory.</p>
-</div>
-<div class="section" id="the-sequencehandle">
-<h2>The SequenceHandle<a class="headerlink" href="#the-sequencehandle" title="Permalink to this headline">¶</a></h2>
-<dl class="function">
-<dt id="ost.seq.CreateSequence">
-<tt class="descclassname">ost.seq.</tt><tt class="descname">CreateSequence</tt><big>(</big><em>name</em>, <em>sequence</em><big>)</big><a class="headerlink" href="#ost.seq.CreateSequence" title="Permalink to this definition">¶</a></dt>
-<dd><p>Create a new <a class="reference internal" href="#ost.seq.SequenceHandle" title="ost.seq.SequenceHandle"><tt class="xref py py-class docutils literal"><span class="pre">SequenceHandle</span></tt></a> with the given name and sequence.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>name</strong> – name of the sequence</li>
-<li><strong>sequence</strong> – String of characters representing the sequence. Only
-alphanumerical characters and ‘-‘ are allowed.</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name" colspan="2">Raises InvalidSequence:</th></tr>
-<tr><td> </td><td class="field-body"><p class="first last">When the sequence string contains forbidden
-characters, that is anything that is not alphanumeric or a hyphen.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.seq.SequenceHandle">
-<em class="property">class </em><tt class="descclassname">ost.seq.</tt><tt class="descname">SequenceHandle</tt><a class="headerlink" href="#ost.seq.SequenceHandle" title="Permalink to this definition">¶</a></dt>
-<dd><p>Represents a sequence. New instances are created with <a class="reference internal" href="#ost.seq.CreateSequence" title="ost.seq.CreateSequence"><tt class="xref py py-func docutils literal"><span class="pre">CreateSequence()</span></tt></a>.</p>
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetPos">
-<tt class="descname">GetPos</tt><big>(</big><em>residue_index</em><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetPos" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get position of residue with index in sequence. This is best illustrated in
-the following example:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">s</span><span class="o">=</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateSequence</span><span class="p">(</span><span class="s">"A"</span><span class="p">,</span> <span class="s">"abc---def"</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">s</span><span class="o">.</span><span class="n">GetPos</span><span class="p">(</span><span class="mf">1</span><span class="p">)</span> <span class="c"># prints 1</span>
-<span class="k">print</span> <span class="n">s</span><span class="o">.</span><span class="n">GetPos</span><span class="p">(</span><span class="mf">3</span><span class="p">)</span> <span class="c"># prints 6</span>
-</pre></div>
-</div>
-<p>The reverse mapping, that is from position in the sequence to residue index
-can be achieved with <a class="reference internal" href="#ost.seq.SequenceHandle.GetResidueIndex" title="ost.seq.SequenceHandle.GetResidueIndex"><tt class="xref py py-meth docutils literal"><span class="pre">GetResidueIndex()</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetResidueIndex">
-<tt class="descname">GetResidueIndex</tt><big>(</big><em>pos</em><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetResidueIndex" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get residue index of character at given position. This method is the
-inverse of <a class="reference internal" href="#ost.seq.SequenceHandle.GetPos" title="ost.seq.SequenceHandle.GetPos"><tt class="xref py py-meth docutils literal"><span class="pre">GetPos()</span></tt></a>. If the sequence contains a gap at that position,
-an <tt class="xref py py-exc docutils literal"><span class="pre">Error</span></tt> is raised.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">s</span><span class="o">=</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateSequence</span><span class="p">(</span><span class="s">"A"</span><span class="p">,</span> <span class="s">"abc--def"</span><span class="p">)</span>
-<span class="k">print</span> <span class="n">s</span><span class="o">.</span><span class="n">GetResidueIndex</span><span class="p">(</span><span class="mf">1</span><span class="p">)</span> <span class="c"># prints 1</span>
-<span class="k">print</span> <span class="n">s</span><span class="o">.</span><span class="n">GetResidueIndex</span><span class="p">(</span><span class="mf">6</span><span class="p">)</span> <span class="c"># prints 4</span>
-<span class="c"># the following line raises an exception of type</span>
-<span class="c"># Error with the message "requested position contains</span>
-<span class="c"># a gap"</span>
-<span class="k">print</span> <span class="n">s</span><span class="o">.</span><span class="n">GetResidueIndex</span><span class="p">(</span><span class="mf">3</span><span class="p">)</span>
-</pre></div>
-</div>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetLastNonGap">
-<tt class="descname">GetLastNonGap</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetLastNonGap" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get position of last non-gap character in sequence. In case of an empty
-sequence, or, a sequence only consisting of hyphens, -1 is returned</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetFirstNonGap">
-<tt class="descname">GetFirstNonGap</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetFirstNonGap" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get position of first non-gap character in sequence. In case of an empty
-sequence, or, a sequence only consisting of hyphens, -1 is returned.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.AttachView">
-<tt class="descname">AttachView</tt><big>(</big><em>view</em><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.AttachView" title="Permalink to this definition">¶</a></dt>
-<dt>
-<tt class="descname">AttachView</tt><big>(</big><em>view</em><span class="optional">[</span>, <em>chain_name</em><span class="optional">]</span><big>)</big></dt>
-<dd><p>Attach an <tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt> to sequence. The first signature requires
-that the view contains one chain. If not, an <tt class="xref py py-exc docutils literal"><span class="pre">IntegrityError</span></tt> is
-raised. The second signature will select the chain with the given name. If
-no such chain exists, an <tt class="xref py py-exc docutils literal"><span class="pre">IntegrityError</span></tt> is raised.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.HasAttachedView">
-<tt class="descname">HasAttachedView</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.HasAttachedView" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns True when the sequence has a view attached, False if not.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetAttachedView">
-<tt class="descname">GetAttachedView</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetAttachedView" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the attached <tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt>, or an invalid
-<tt class="xref py py-class docutils literal"><span class="pre">EntityView</span></tt> if no view has been attached. Also available as
-the property <a class="reference internal" href="#ost.seq.SequenceHandle.attached_view" title="ost.seq.SequenceHandle.attached_view"><tt class="xref py py-attr docutils literal"><span class="pre">attached_view</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetName">
-<tt class="descname">GetName</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetName" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the name of the sequence. Also available as the property
-<a class="reference internal" href="#ost.seq.SequenceHandle.name" title="ost.seq.SequenceHandle.name"><tt class="xref py py-attr docutils literal"><span class="pre">name</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.SetSequenceOffset">
-<tt class="descname">SetSequenceOffset</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.SetSequenceOffset" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the <a class="reference internal" href="#sequence-offset"><em>sequence offset</em></a>. By default, the offset is
-0. Also available as the property <a class="reference internal" href="#ost.seq.SequenceHandle.sequence_offset" title="ost.seq.SequenceHandle.sequence_offset"><tt class="xref py py-attr docutils literal"><span class="pre">sequence_offset</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetSequenceOffset">
-<tt class="descname">GetSequenceOffset</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetSequenceOffset" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the <a class="reference internal" href="#sequence-offset"><em>sequence offset</em></a>. Also available as
-<a class="reference internal" href="#ost.seq.SequenceHandle.sequence_offset" title="ost.seq.SequenceHandle.sequence_offset"><tt class="xref py py-attr docutils literal"><span class="pre">sequence_offset</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.GetGaplessString">
-<tt class="descname">GetGaplessString</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.GetGaplessString" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a string version of this sequence with all hyphens removed. Also
-available as the property <a class="reference internal" href="#ost.seq.SequenceHandle.gapless_string" title="ost.seq.SequenceHandle.gapless_string"><tt class="xref py py-attr docutils literal"><span class="pre">gapless_string</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.SetName">
-<tt class="descname">SetName</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.SetName" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set name of the sequence. Also available as the property <a class="reference internal" href="#ost.seq.SequenceHandle.name" title="ost.seq.SequenceHandle.name"><tt class="xref py py-attr docutils literal"><span class="pre">name</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.seq.SequenceHandle.gapless_string">
-<tt class="descname">gapless_string</tt><a class="headerlink" href="#ost.seq.SequenceHandle.gapless_string" title="Permalink to this definition">¶</a></dt>
-<dd><p>Shorthand for <a class="reference internal" href="#ost.seq.SequenceHandle.GetGaplessString" title="ost.seq.SequenceHandle.GetGaplessString"><tt class="xref py py-meth docutils literal"><span class="pre">GetGaplessString()</span></tt></a></p>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.seq.SequenceHandle.name">
-<tt class="descname">name</tt><a class="headerlink" href="#ost.seq.SequenceHandle.name" title="Permalink to this definition">¶</a></dt>
-<dd><p>Shorthand for <a class="reference internal" href="#ost.seq.SequenceHandle.GetName" title="ost.seq.SequenceHandle.GetName"><tt class="xref py py-meth docutils literal"><span class="pre">GetName()</span></tt></a>/<a class="reference internal" href="#ost.seq.SequenceHandle.SetName" title="ost.seq.SequenceHandle.SetName"><tt class="xref py py-meth docutils literal"><span class="pre">SetName()</span></tt></a></p>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.seq.SequenceHandle.attached_view">
-<tt class="descname">attached_view</tt><a class="headerlink" href="#ost.seq.SequenceHandle.attached_view" title="Permalink to this definition">¶</a></dt>
-<dd><p>Shorthand for <a class="reference internal" href="#ost.seq.SequenceHandle.GetAttachedView" title="ost.seq.SequenceHandle.GetAttachedView"><tt class="xref py py-meth docutils literal"><span class="pre">GetAttachedView()</span></tt></a>.</p>
-</dd></dl>
-
-<dl class="attribute">
-<dt id="ost.seq.SequenceHandle.sequence_offset">
-<tt class="descname">sequence_offset</tt><a class="headerlink" href="#ost.seq.SequenceHandle.sequence_offset" title="Permalink to this definition">¶</a></dt>
-<dd><p>Shorthand for <a class="reference internal" href="#ost.seq.SequenceHandle.GetSequenceOffset" title="ost.seq.SequenceHandle.GetSequenceOffset"><tt class="xref py py-meth docutils literal"><span class="pre">GetSequenceOffset()</span></tt></a>/<a class="reference internal" href="#ost.seq.SequenceHandle.SetSequenceOffset" title="ost.seq.SequenceHandle.SetSequenceOffset"><tt class="xref py py-meth docutils literal"><span class="pre">SetSequenceOffset()</span></tt></a></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.__len__">
-<tt class="descname">__len__</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.__len__" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the length of the sequence (including insertions and deletions)</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.SequenceHandle.__str__">
-<tt class="descname">__str__</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.SequenceHandle.__str__" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the sequence as a string.</p>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-<div class="section" id="the-sequencelist">
-<h2>The SequenceList<a class="headerlink" href="#the-sequencelist" title="Permalink to this headline">¶</a></h2>
-<dl class="class">
-<dt id="ost.seq.SequenceList">
-<em class="property">class </em><tt class="descclassname">ost.seq.</tt><tt class="descname">SequenceList</tt><a class="headerlink" href="#ost.seq.SequenceList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Represents a list of sequences. The class provides a row-based interface. New
-instances are created with <tt class="xref py py-func docutils literal"><span class="pre">CreateSequenceList()</span></tt>.</p>
-</dd></dl>
-
-</div>
-<div class="section" id="the-alignmenthandle">
-<h2>The AlignmentHandle<a class="headerlink" href="#the-alignmenthandle" title="Permalink to this headline">¶</a></h2>
-<p>The <a class="reference internal" href="#ost.seq.AlignmentHandle" title="ost.seq.AlignmentHandle"><tt class="xref py py-class docutils literal"><span class="pre">AlignmentHandle</span></tt></a> represents a list of aligned sequences. In
-constrast to <a class="reference internal" href="#ost.seq.SequenceList" title="ost.seq.SequenceList"><tt class="xref py py-class docutils literal"><span class="pre">SequenceList</span></tt></a>, an alignment requires all sequences to be of
-the same length. New instances of alignments are created with
-<a class="reference internal" href="#ost.seq.CreateAlignment" title="ost.seq.CreateAlignment"><tt class="xref py py-func docutils literal"><span class="pre">CreateAlignment()</span></tt></a> and <a class="reference internal" href="#ost.seq.AlignmentFromSequenceList" title="ost.seq.AlignmentFromSequenceList"><tt class="xref py py-func docutils literal"><span class="pre">AlignmentFromSequenceList()</span></tt></a>.</p>
-<p>Typically sequence alignments are used column-based, i.e by looking at an
-aligned columns in the sequence alignment. To get a row-based (sequence) view
-on the sequence list, use <tt class="xref py py-meth docutils literal"><span class="pre">GetSequenceList()</span></tt>.</p>
-<p>All functions that operate on an alignment will again produce a valid alignment.
-This mean that it is not possible to change the length of one sequence, without
-adjusting the other sequences, too.</p>
-<p>The following example shows how to iterate over the columns and sequences of
-an alignment:</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">aln</span><span class="o">=</span><span class="n">io</span><span class="o">.</span><span class="n">LoadAlignment</span><span class="p">(</span><span class="s">'aln.fasta'</span><span class="p">)</span>
-<span class="c"># iterate over the columns</span>
-<span class="k">for</span> <span class="n">col</span> <span class="ow">in</span> <span class="n">aln</span><span class="p">:</span>
- <span class="k">print</span> <span class="n">col</span>
-
-<span class="c"># iterate over the sequences</span>
-<span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">aln</span><span class="o">.</span><span class="n">sequences</span><span class="p">:</span>
- <span class="k">print</span> <span class="n">s</span>
-</pre></div>
-</div>
-<dl class="function">
-<dt id="ost.seq.CreateAlignment">
-<tt class="descclassname">ost.seq.</tt><tt class="descname">CreateAlignment</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.CreateAlignment" title="Permalink to this definition">¶</a></dt>
-<dd><p>Creates and returns a new <a class="reference internal" href="#ost.seq.AlignmentHandle" title="ost.seq.AlignmentHandle"><tt class="xref py py-class docutils literal"><span class="pre">AlignmentHandle</span></tt></a> with no sequences.</p>
-</dd></dl>
-
-<dl class="function">
-<dt id="ost.seq.AlignmentFromSequenceList">
-<tt class="descclassname">ost.seq.</tt><tt class="descname">AlignmentFromSequenceList</tt><big>(</big><em>sequences</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentFromSequenceList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Create a new alignment from the given list of sequences</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first simple">
-<li><strong>sequences</strong> (<em>ConstSequenceList</em>) – the list of sequences</li>
-</ul>
-</td>
-</tr>
-<tr class="field"><th class="field-name">Raises :</th><td class="field-body"><p class="first last"><tt class="xref py py-exc docutils literal"><span class="pre">InvalidAlignment</span></tt> if the sequences do not have the same length.</p>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="class">
-<dt id="ost.seq.AlignmentHandle">
-<em class="property">class </em><tt class="descclassname">ost.seq.</tt><tt class="descname">AlignmentHandle</tt><a class="headerlink" href="#ost.seq.AlignmentHandle" title="Permalink to this definition">¶</a></dt>
-<dd><div class="admonition note">
-<p class="first admonition-title">Note</p>
-<p class="last">Several of these methods just forward calls to the sequence. For more
-detailed information, have a look at the <a class="reference internal" href="#ost.seq.SequenceHandle" title="ost.seq.SequenceHandle"><tt class="xref py py-class docutils literal"><span class="pre">SequenceHandle</span></tt></a>
-documentation.</p>
-</div>
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.GetSequence">
-<tt class="descname">GetSequence</tt><big>(</big><em>index</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.GetSequence" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the sequence at the given index, raising an IndexError when trying
-to access an inexistent sequence.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.GetSequenceList">
-<tt class="descname">GetSequenceList</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.GetSequenceList" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a list of all sequence of the alignment.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.GetLength">
-<tt class="descname">GetLength</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.GetLength" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the length of the alignment.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.GetCount">
-<tt class="descname">GetCount</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.GetCount" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns the number of sequences in the alignment.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.ToString">
-<tt class="descname">ToString</tt><big>(</big><em>width=80</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.ToString" title="Permalink to this definition">¶</a></dt>
-<dd><p>Returns a formatted string version of the alignment. The sequences are
-split into smaller parts to fit into the number columns specified.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">aln</span><span class="o">=</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateAlignment</span><span class="p">()</span>
-<span class="n">aln</span><span class="o">.</span><span class="n">AddSequence</span><span class="p">(</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateSequence</span><span class="p">(</span><span class="s">"A"</span><span class="p">,</span> <span class="s">"abcdefghik"</span><span class="p">))</span>
-<span class="n">aln</span><span class="o">.</span><span class="n">AddSequence</span><span class="p">(</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateSequence</span><span class="p">(</span><span class="s">"B"</span><span class="p">,</span> <span class="s">"1234567890"</span><span class="p">))</span>
-<span class="c"># The following command will print the output given below</span>
-<span class="k">print</span> <span class="n">aln</span><span class="o">.</span><span class="n">ToString</span><span class="p">(</span><span class="mf">7</span><span class="p">)</span>
-<span class="c"># A abcde</span>
-<span class="c"># B 12345</span>
-<span class="c">#</span>
-<span class="c"># A fghik</span>
-<span class="c"># B 67890</span>
-</pre></div>
-</div>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.FindSequence">
-<tt class="descname">FindSequence</tt><big>(</big><em>name</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.FindSequence" title="Permalink to this definition">¶</a></dt>
-<dd><p>Find sequence with given name. If the alignment contains several sequences
-with the same name, the first sequence is returned.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.SetSequenceName">
-<tt class="descname">SetSequenceName</tt><big>(</big><em>seq_index</em>, <em>name</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.SetSequenceName" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the name of the sequence at index <cite>seq_index</cite> to name</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.SetSequenceOffset">
-<tt class="descname">SetSequenceOffset</tt><big>(</big><em>seq_index</em>, <em>offset</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.SetSequenceOffset" title="Permalink to this definition">¶</a></dt>
-<dd><p>Set the sequence offset of sequence at index <cite>seq_index</cite></p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.Copy">
-<tt class="descname">Copy</tt><big>(</big><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.Copy" title="Permalink to this definition">¶</a></dt>
-<dd><p>Create a deep copy of the alignment</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.GetPos">
-<tt class="descname">GetPos</tt><big>(</big><em>seq_index</em>, <em>res_index</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.GetPos" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get position of residue with index equal to <cite>res_index</cite> in sequence at index
-<cite>seq_index</cite>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.GetResidueIndex">
-<tt class="descname">GetResidueIndex</tt><big>(</big><em>seq_index</em>, <em>pos</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.GetResidueIndex" title="Permalink to this definition">¶</a></dt>
-<dd><p>Get residue index of residue at position <cite>pos</cite> in sequence at index
-<cite>seq_index</cite>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.AttachView">
-<tt class="descname">AttachView</tt><big>(</big><em>seq_index</em>, <em>view</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.AttachView" title="Permalink to this definition">¶</a></dt>
-<dt>
-<tt class="descname">AttachView</tt><big>(</big><em>seq_index</em>, <em>view</em>, <em>chain_name</em><big>)</big></dt>
-<dd><p>Attach the given view to the sequence at index <cite>seq_index</cite>.</p>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.Cut">
-<tt class="descname">Cut</tt><big>(</big><em>start</em>, <em>end</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.Cut" title="Permalink to this definition">¶</a></dt>
-<dd><p>Removes the columns in the half-closed interval <cite>start</cite>, <cite>end</cite> from the
-alignment.</p>
-<div class="highlight-python"><div class="highlight"><pre><span class="n">aln</span><span class="o">=</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateAlignment</span><span class="p">()</span>
-<span class="n">aln</span><span class="o">.</span><span class="n">AddSequence</span><span class="p">(</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateSequence</span><span class="p">(</span><span class="s">"A"</span><span class="p">,</span> <span class="s">"abcd---hik"</span><span class="p">))</span>
-<span class="n">aln</span><span class="o">.</span><span class="n">AddSequence</span><span class="p">(</span><span class="n">seq</span><span class="o">.</span><span class="n">CreateSequence</span><span class="p">(</span><span class="s">"B"</span><span class="p">,</span> <span class="s">"1234567890"</span><span class="p">))</span>
-<span class="n">aln</span><span class="o">.</span><span class="n">Cut</span><span class="p">(</span><span class="mf">4</span><span class="p">,</span> <span class="mf">7</span><span class="p">)</span>
-
-<span class="k">print</span> <span class="n">aln</span><span class="o">.</span><span class="n">ToString</span><span class="p">(</span><span class="mf">80</span><span class="p">)</span>
-<span class="c"># will print</span>
-<span class="c"># A abcdhik</span>
-<span class="c"># B 1234890</span>
-</pre></div>
-</div>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.Replace">
-<tt class="descname">Replace</tt><big>(</big><em>new_region</em>, <em>start</em>, <em>end</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.Replace" title="Permalink to this definition">¶</a></dt>
-<dd><p>Replace the columns in the half-closed interval <cite>start</cite>, <cite>end</cite> with the
-columns in <cite>new_region</cite>.</p>
-<table class="docutils field-list" frame="void" rules="none">
-<col class="field-name" />
-<col class="field-body" />
-<tbody valign="top">
-<tr class="field"><th class="field-name">Parameters:</th><td class="field-body"><ul class="first last simple">
-<li><strong>new_region</strong> (<em>AlignedRegionAlignmentHandle</em>) – The region to be inserted</li>
-</ul>
-</td>
-</tr>
-</tbody>
-</table>
-</dd></dl>
-
-<dl class="method">
-<dt id="ost.seq.AlignmentHandle.ShiftRegion">
-<tt class="descname">ShiftRegion</tt><big>(</big><em>start</em>, <em>end</em>, <em>amount</em>, <em>master=-1</em><big>)</big><a class="headerlink" href="#ost.seq.AlignmentHandle.ShiftRegion" title="Permalink to this definition">¶</a></dt>
-<dd><p>Shift columns in the half-closed interval <cite>start</cite>, <cite>end</cite>. If amount is a
-positive number, the columns are shifted to the right, if negative, the
-columns are shifted to the left.</p>
-<p>If master is set to -1, all sequences in the region are affected, otherwise
-only the sequence at index equal to master is shifted.</p>
-</dd></dl>
-
-</dd></dl>
-
-</div>
-</div>
-
-
- </div>
- </div>
- </div>
- <div class="clearer"></div>
- </div>
- <div class="related">
- <h3>Navigation</h3>
- <ul>
- <li class="right" style="margin-right: 10px">
- <a href="../../genindex.html" title="General Index"
- >index</a></li>
- <li class="right" >
- <a href="../../py-modindex.html" title="Python Module Index"
- >modules</a> |</li>
- <li class="right" >
- <a href="../../base/base.html" title="ost.settings - Locate Files and Retrieve Preferences"
- >next</a> |</li>
- <li class="right" >
- <a href="../../mol/base/query.html" title="Queries"
- >previous</a> |</li>
- <li><a href="../../index.html">OpenStructure v1.0 documentation</a> »</li>
- </ul>
- </div>
- <div class="footer">
- © Copyright 2010, OpenStructure authors.
- Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0b2.
- </div>
- </body>
-</html>
\ No newline at end of file
diff --git a/doc/source/base/base.rst b/doc/source/base/base.rst
deleted file mode 100644
index 8bec08e983113dffdae61f80ef509ae6fecd9abe..0000000000000000000000000000000000000000
--- a/doc/source/base/base.rst
+++ /dev/null
@@ -1,9 +0,0 @@
-:mod:`ost.settings` - Locate Files and Retrieve Preferences
-================================================================================
-
-.. automodule:: ost.settings
- :synopsis: Helper Functions to Locate Files and Retrieve Preferences
- :members:
-
-
-
diff --git a/doc/source/base/generic.rst b/doc/source/base/generic.rst
deleted file mode 100644
index 6c2cd34cb6d0a29b75a8a8470c6b07a8f7e67d7d..0000000000000000000000000000000000000000
--- a/doc/source/base/generic.rst
+++ /dev/null
@@ -1,157 +0,0 @@
-Storing Custom Data
-================================================================================
-
-Introduction
---------------------------------------------------------------------------------
-
-It is often very convenient to store any arbitrary data inside an Entity. A few examples are:
-
- * calculated properties of atoms
- * sequence conservation of a residue
- * interaction energy of a substructure with its surrounding
- * fit of a fragment inside an electron density map
-
-In OpenStructure this is supported by the use of generic properties. Most
-building blocks are derived from :class:`GenericPropertyContainer`, meaning that
-arbitrary key-value pairs can be stored in them. In essence, the following
-classes support generic properties:
-
- * :class:`~mol.EntityHandle` and :class:`~mol.EntityView`
- * :class:`~mol.ChainHandle` and :class:`~mol.ChainView`
- * :class:`~ResidueHandle` and :class:`~mol.ResidueView`
- * :class:`~mol.AtomHandle` and :class:`~mol.AtomView`
- * :class:`~mol.BondHandle`
- * :class:`~seq.SequenceHandle` and :class:`~seq.AlignmentHandle`
-
-The view variants will reflect the generic properties of the handle variants.
-
-A generic property key is always a string, and a value can be one of string, float, int or bool. For each of these data types, methods to retrieve and store values are available both in Python and C++.
-
-Storing and Accessing Data
---------------------------------------------------------------------------------
-
-All OpenStructure building blocks that are :class:`GenericPropContainers`, have
-four different methods to store generic data, depending on the data type (i.e.
-string, float, int or bool).
-
-To store a float value with the key 'myfloatprop' in all atoms of an entity:
-
-.. code-block:: python
-
- import math
- for atom in entity.GetAtomList():
- val=5*math.sin(0.4*atom.GetPos().GetX())
- atom.SetFloatProp("myfloatprop", val)
-
-If a GenericProp at a given level (i.e. atom, bond, residue, chain or entity)
-already exists, it will be overwritten. To check if it exists, use:
-
-.. code-block:: python
-
- exists=atom.HasProp("myfloatprop")
- print exists
-
-To access the value of a generic property, we first check if the property exists
-and then access it, using the method suitable for the data type of the property.
-For the previously set property "myfloatprop" of the data type real, at the atom
-level:
-
-.. code-block:: python
-
- for atom in entity.GetAtomList():
- if atom.HasProp("myfloatprop"):
- print atom.GetFloatProp("myfloatprop")
-
-When trying to access a property that has not been set, or one that has been
-set, but at a different level, an error is thrown. The same is true when trying
-to access a property of a different data type, e.g.:
-
-.. code-block:: python
-
- # all of the following lines will throw errors
- # error because the property does not exist
- print atom.GetFloatProp("unknownprop")
-
- # error because the property was set at another level
- print entity.GetFloatProp("myfloatprop")
-
- # error because the data type of the property is different
- print atom.GetStringProp("myfloatprop")
-
-
-Use of Generic Properties in Queries
---------------------------------------------------------------------------------
-
-The :doc:`../mol/base/query` can also be used for numeric generic properties (i.e. bool,
-int, float), but the syntax is slightly different. To access any generic
-properties, it needs to be specified that they are generic and at which level
-they are defined. Therefore, all generic properties start with a 'g', followed
-by an 'a', 'r' or 'c' for atom, residue or chain level respectively. For more
-details see :doc:`../mol/base/query`.
-
-
-API documentation
---------------------------------------------------------------------------------
-
-.. class:: GenericPropertyContainer
-
- .. method:: HasProp(key)
-
- checks existence of property. Returns true, if the the class contains a
- property with the given name, false if not.
-
- .. method:: GetPropAsString(key)
-
- Returns the string representation of a property, or the empty String if
- the property addressed by key does not exist. Note that this is not the
- same as trying to get a generic float/int/bool property as a string type;
- the latter will result in a boost:get exception. Use this method to obtain
- a representation suitable for output.
-
- .. method:: GetStringProp(key)
- GetStringProp(key, default_value)
-
- Get string property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
-
- .. method:: GetFloatProp(key)
- GetFloatProp(key, default_value)
-
- Get float property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
-
- .. method:: GetIntProp(key)
- GetIntProp(key, default_value)
-
- Get int property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
- .. method:: GetBoolProp(key)
- GetBoolProp(key, default_value)
-
- Get bool property. The first signature raises a GenericPropError error if
- the property does not exist, the second returns the default value.
-
- .. method:: ClearProps()
-
- Remove all generic properties
-
-
- .. method:: SetStringProp(key, value)
-
- Set string property, overriding an existing property with the same name
-
- .. method:: SetFloatProp(key, value)
-
- Set float property, overriding an existing property with the same name
-
- .. method:: SetIntProp(key, value)
-
- Set int property, overriding an existing property with the same name
-
- .. method:: SetBoolProp(key, value)
-
- Set bool property, overriding a property with the same name
-
diff --git a/doc/source/conop/conop.rst b/doc/source/conop/conop.rst
deleted file mode 100644
index a7ebe2eaa24fd6cb3c6f2990e9ba939b77644544..0000000000000000000000000000000000000000
--- a/doc/source/conop/conop.rst
+++ /dev/null
@@ -1,255 +0,0 @@
-:mod:`~ost.conop` -- Connectivity and Topology of Molecules
-================================================================================
-
-.. module:: ost.conop
- :synopsis: The conop modules implement different strategies to derive
- connectivity information of molecules.
-
-The main task of the conop module is to connect atoms with bonds. While the
-bond class is also part of the base module, the conop module deals with setting
-up the correct bonds between atoms.
-
-Motivation
---------------------------------------------------------------------------------
-Traditionally the connectivity between atoms has not been reliably described in
-a PDB file. Different programs adopted various ways of finding out if two atoms
-are connected. One way chosen is to rely on proper naming of the atoms. For
-example, the backbone atoms of the standard amino acids are named as N, CA, C
-and O and if atoms with these name appear in the same residue they are shown
-connected. Another way is to apply additional heuristics to find out if a
-peptide bond between two consecutive residues is formed. Breaks in the backbone
-are indicated, e.g., by introducing a discontinuity in the numbering of the residue.
-
-Loader heuristics are great if you are the one that implemented them but are
-problematic if you are just the user of a software that has them. As time goes
-on, these heuristics become buried in thousands of lines of code and they are
-often hard yet impossible to trace back.
-
-Different clients of the framework have different requirements. A visualisation
-software wants to read in a PDB files as is without making any changes. A
-script in an automated pipeline, however, does want to either strictly reject
-files that are incomplete or fill-in missing structural features. All these
-aspects are implemented in the conop module, separated from the loading of the
-PDB file, giving clients a fine grained control over the loading process.
-
-The Builder interface
---------------------------------------------------------------------------------
-
-The conop module defines a :class:`Builder` interface, to run connectivity
-algorithms, that is to connect the atoms with bonds and perform basic clean up
-of errorneous structures. The clients of the conop module can specify how the
-Builder should treat unknown amino acids, missing atoms and chemically
-infeasible bonds.
-
-The exact behaviour for a builder is implementation-specific. So far, two
-classes implement the Builder interface: A heuristic and a rule-based builder. The builders mainly differ in the source of their connectivity information. The
-HeuristicBuilder uses a hard-coded heuristic connectivity table for the 20
-standard amino acids as well as nucleotides.For other compounds such as ligands
-the HeuristicBuilder runs a distance-based connectivity algorithm that connects
-two atoms if they are closer than a certain threshold. The RuleBasedBuilder
-uses a connectivity library containing all molecular components present in the
-PDB files on PDB.org. The library can easily be extended with custom
-connectivity information, if required. By default the heuristic builder is used,
-however the builder may be switched by setting the !RuleBasedBuilder as the
-default. To do so, one has first to create a new instance of a RuleBasedBuilder
-and register it in the builder registry of the conop module. In Python, this can
-be achieved with
-
-.. code-block:: python
-
- from ost import conop
- compound_lib=conop.CompoundLib.Load('...')
- rbb=conop.RuleBasedBuilder(compound_lib)
- conop.Conopology.Instance().RegisterBuilder(rbb,'rbb')
- conop.Conopology.Instance().SetDefaultBuilder('rbb')
-
-All subsequent calls to :func:`io.LoadEntity` will make use of the
-RuleBasedBuilder instead of the heuristic builder. See
-:ref:`here <mmcif-convert>` for more information on how to create the necessary
-files to use the rule-based builder.
-
-
-.. class:: Builder
-
- .. method:: CompleteAtoms(residue)
-
- add any missing atoms to the residue based on its key, with coordinates set
- to zero.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: CheckResidueCompleteness(residue)
-
- verify that the given residue has all atoms it is supposed to have based on
- its key.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: IsResidueComplete(residue)
-
- Check whether the residue has all atoms it is supposed to have. Hydrogen
- atoms are not required for a residue to be complete.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: IdentifyResidue(residue)
-
- attempt to identify the residue based on its atoms, and return a suggestion
- for the proper residue key.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: ConnectAtomsOfResidue(residue)
-
- Connects atoms of residue based on residue and atom name. This method does
- not establish inter-residue bonds. To connect atoms that belong to
- different residues, use :meth:`ConnectResidueToPrev`, or
- :meth:`ConnectResidueToNext`.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: ConnectResidueToPrev(residue, prev)
-
- Connect atoms of residue to previous. The order of the parameters is
- important. In case of a polypeptide chain, the residues are thought to be
- ordered from N- to C- terminus.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
- :param prev: valid or invalid residue
- :type prev: mol.ResidueHandle
-
-
- .. method:: DoesPeptideBondExist(n, c)
-
- Check if peptide bond should be formed between the `n` and `c` atom. This
- method is called by ConnectResidueWithNext() after making sure that
- both residues participating in the peptide bond are peptide linking
- components.
-
- By default, :meth:`IsBondFeasible` is used to check whether the two atoms
- form a peptide bond.
-
- :param n: backbone nitrogen atom (IUPAC name `N`). Must be valid.
- :type n: mol.AtomHandle
- :param c: backbone C-atom (IUPAC name `C`). Must be valid.
- :type c: mol.AtomHandle
-
- .. method:: IsBondFeasible(atom_a, atom_b)
-
- Overloadable hook to check if bond between to atoms is feasible. The
- default implementation uses a distance-based check to check if the
- two atoms should be connected. The atoms are connected if they are in
- the range of 0.8 to 1.2 times their van-der-WAALS radius.
-
- :param atom_a: a valid atom
- :type atom_b: mol.AtomHandle
- :param atom_a: a valid atom
- :type atom_b: mol.AtomHandle
-
- .. method:: GuessAtomElement(atom_name, hetatm)
-
- guess element of atom based on name and hetatm flag
-
- :param atom_name: IUPAC atom name, e.g. `CA`, `CB` or `N`.
- :type atom_name: string
- :param hetatm: Whether the atom is a hetatm or not
- :type hetatm: bool
-
- .. method:: AssignBackboneTorsionsToResidue(residue)
-
- For :meth:`peptide-linking residues <mol.ResidueHandle.IsPeptideLinking>`,
- residues, assigns phi, psi and omega torsions to amino acid.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
-
-.. class:: RuleBasedBuilder
-
- The :class:`RuleBasedBuilder` implements the :class:`Builder` interface.
- Refer to its documentation for a basic description of the methods.
-
- .. method:: CheckResidueCompleteness(residue)
-
- By using the description of the chemical compound, the completeness of
- the residue is verified. The method distinguishes between required atoms
- and atoms that are optional, like `OXT` that is only present, if not
- peptide bond is formed. Whenever an unknown atom is encountered,
- :meth:`OnUnknownAtom` is invoked. Subclasses of the
- :class:`RuleBasedBuilder` may implement some additional logic to deal with
- unknown atom. Likewise, whenever a required atom is missing,
- :meth:`OnMissingAtom` is invoked. Hydrogen atoms are not considered as
- required by default.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
- .. method:: IdentifyResidue(residue)
-
- Looks-up the residue in the database of chemical compounds and returns
- the name of the residue or "UNK" if the residue has not been found in the
- library.
-
- :param residue: must be a valid residue
- :type residue: mol.ResidueHandle
-
-
- .. method:: OnUnknownAtom(atom)
-
- Invoked whenever an unkknown atom has been encountered during a residue
- completeness check.
-
- The default implementation guesses the atom properties based on the name
- and returns false, meaning that it should be treated as an unknown atom.
-
- Custom implementations of this method may delete the atom, or modify it.
-
- :param atom: the unknown atom
- :type atom: mol.AtomHandle
-
- .. method:: OnMissingAtom(atom)
-
- Invoked whenever an atom is missing. It is up to the overloaded method
- to deal with the missing atom, either by ignoring it or by inserting a
- dummy atom.
-
- :param atom: The missing atom's name
- :type atom: string
-
-Connecting atoms
---------------------------------------------------------------------------------
-
-The high level interface is exposed by the Conopoloy singleton instance:
-
-.. code-block:: python
-
- import conop
-
- cc=conop.Conopology.Instance()
-
- ent=BuildRawModel(...)
- cc.ConnectAll(cc.GetBuilder(), ent)
-
-For fine grained control, the builder interface may be used directly.
-
-
-.. _mmcif-convert:
-
-Convert MM CIF dictionary
---------------------------------------------------------------------------------
-
-The CompoundLib may be created from a MM CIF dictionary. The latest dictionary
-can be found on the `wwPDB site <http://www.wwpdb.org/ccd.html>`_.
-
-After downloading the file in MM CIF use the :program:`chemdict_tool` to convert
-the MM CIF dictionary into our internal format.
-
-.. code-block:: bash
-
- chemdict_tool create <components.cif> <compounds.chemlib>
diff --git a/doc/source/external.rst b/doc/source/external.rst
deleted file mode 100644
index 7ea3b22db79befda28b9a262e95a91cd64b26d6d..0000000000000000000000000000000000000000
--- a/doc/source/external.rst
+++ /dev/null
@@ -1,111 +0,0 @@
-Using External Programs within OpenStructure
-================================================================================
-
-Introduction
---------------------------------------------------------------------------------
-
-It is often very useful to use external programs to do a specific task. In principle, this can be done by writing out files from OpenStructure and manually running an external program, however, for convenience, this can also be done directly from within OpenStructure using Python commands.
-
-This tutorial will give you some hints how to do this for a new external program. The process basically consists of four steps:
-
- * locate the executable of the external program
- * prepare all necessary files
- * execute the external program from python
- * read in generated output
-
-
-Locating the Executable
---------------------------------------------------------------------------------
-
-There is a helper function available to locate files, and especially executables: :func:`~ost.settings.Locate`. Using this, you can obtain the full path of an executable.
-
-As an example, we would like to obtain the full path of the msms executable (a program to calculate molecular surfaces):
-
-.. code-block:: python
-
- from ost import settings
- exe_path=settings.Locate('msms', search_paths=['/opt/app','/home/app'],
- env_name='MSMS', search_system_paths=True)
- print exe_path
-
-The :func:`~ost.settings.Locate` command looks for the program with the name
-`msms`. If env_name is set, it first looks if an environment variable with the
-name `MSMS` is set. If not, all paths in search_paths are searched. If the
-executable could still not be found and search_system_paths is set to True, the
-binary search paths are searched. If the executable could not be found, a
-:exc:`~ost.FileNotFound` exception is raised with a detailed description where
-Locate was searching for the executable.
-
-Prepare All Files
---------------------------------------------------------------------------------
-
-The preparation of the necessary files is very dependent on the external program. Often it is useful to generate a temporary directory or file. For this, the python module tempfile is very handy.
-
-An example how to generate a temporary directory, open a file in this directory and write the position and radius of all atoms into this file is shown here:
-
-.. code-block:: python
-
- import tempfile
- import os
-
- # generate a temporary directory
- tmp_dir_name=tempfile.mkdtemp()
- print 'temporary directory:',tmp_dir_name
-
- # generate and open a file in the temp directory
- tmp_file_name=os.path.join(tmp_dir_name,"entity")
- tmp_file_handle=open(tmp_file_name, 'w')
- print 'temporary file:',tmp_file_handle
-
- # write position and radius of all atoms to file
- for a in entity.GetAtomList():
- position=a.GetPos()
- tmp_file_handle.write('%8.3f %8.3f %8.3f %4.2f\n' % (position[0],
- position[1], position[2], a.GetProp().radius))
-
- # close the file
- tmp_file_handle.close()
-
-Execute the External Program
---------------------------------------------------------------------------------
-
-The external program can be executed from python using the python module subprocess.
-
-To run the external program msms from the above example, with the temporary file generated before, we can use the following:
-
-.. code-block:: python
-
- import subprocess
-
- # set the command to execute
- command="%s -if %s -of %s" % (exe_path,
- tmp_file_name, tmp_file_name)
- print 'command:',command
-
- # run the executable with the command
- proc = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE)
- stdout_value, stderr_value = proc.communicate()
-
- #check for successful completion of msms
- if proc.returncode!=0:
- print "WARNING: msms error\n", stdout_value
- raise subprocess.CalledProcessError(proc.returncode, command)
-
- # print everything written to the command line (stdout)
- print stdout_value
-
-Read Generated Output
---------------------------------------------------------------------------------
-
-The last step includes reading of generated files (like in the case of msms) and/or processing of the generated command line output.
-
-Here we first print the command line output and then load the generated msms surface and print the number of vertex points:
-
-.. code-block:: python
-
- # print everything written to the command line (stdout)
- print stdout_value
-
- # read msms surface from file
- surface=io.LoadSurface(tmp_file_name, "msms")
- print 'number of vertices:',len(surface.GetVertexIDList())
diff --git a/doc/source/geom/composite.rst b/doc/source/geom/composite.rst
deleted file mode 100644
index 0271a206bc9d82d42a7661a58a3ab73deac27f2f..0000000000000000000000000000000000000000
--- a/doc/source/geom/composite.rst
+++ /dev/null
@@ -1,529 +0,0 @@
-Geometric Objects
-================================================================================
-
-.. currentmodule:: ost.geom
-
-Geometrical Objects in Two Dimensions
---------------------------------------------------------------------------------
-
-.. class:: Line2()
- Line2(from, to)
-
- Parametric line in two dimensions as defined by an origin and a normalized
- direction vector. The first constructor creates a line with origin (0,0) and
- direction along the x axis. The second signature creates a line originating
- from `from` and pointing towards `to`.
-
- .. method:: At(t)
-
- Returns the point on the line at (signed) distance t from origin.
-
- :param t: free parameter
- :type t: float
- :rtype: :class:`Vec2`
-
-
- .. method:: GetOrigin()
-
- Returns the origin of the line: Also available as :attr:`origin`.
-
- :rtype: :class:`Vec2`
-
- .. method:: GetDirection()
-
- Returns the normalized direction vector. Also available as
- :attr:`direction`.
-
- :rtype: :class:`Vec2`
-
- .. attribute:: direction
-
- .. attribute:: origin
-
-
-.. class:: Rectangle2()
- Rectangle2(top_left, bottom_right)
-
- Axis aligned rectangle. The first signature creates a rectangle with top-left
- corner (-1, -1) and bottom-right corner (1, 1), wheras the second method
- allows to set the top-left and bottom-right corners directly.
-
- :type top_left: :class:`Vec2`
- :param top_left: The top-left corner
- :param bottom_right: The bottom-right corner
- :type bottom_right: :class:`Vec2`
-
- .. method:: GetWidth()
-
- Returns the width of the rectangle. Also available as :attr:`width`.
-
- .. method:: GetHeight()
-
- Returns the height of the rectangle. Also available as :attr:`height`.
-
- .. attribute:: width
-
- :type: float
-
- .. attribute:: height
-
- :type: float
-
- .. method:: GetStart()
-
- Get top-left corner
-
- :rtype: :class:`Vec2`
-
- .. method:: GetEnd()
-
- Get bottom-right corner
-
- :rtype: :class:`Vec2`
-
- .. method:: SetStart(top_left)
-
- Set top-left corner, leaving the bottom-right corner untouched.
-
- .. method:: SetEnd(bottom_right)
-
- Set the bottom-right corner, leaving the top-left corner untouched.
-
-.. class:: Circle2()
- Circle2(circle)
- Circle2(center, radius)
-
- The first signature creates a circle centered at (0, 0) and radius 1.0. The
- second signature creates a circle with the same paramters as `circle`. The
- third signature creates a new circle with given center and radius.
-
- .. method:: SetCenter(center)
-
- Set center of circle
-
- :type center: :class:`Vec2`
- :param center: The new center
-
- .. method:: SetRadius(radius)
-
- Set radius of circle
-
- :type radius: float
- :param center: The new radius
-
- .. method:: GetCenter()
-
- Returns the center of the circle
-
- .. method:: GetRadius()
-
- Returns the radius of the circle
-
- .. method:: GetArea()
-
- Returns the area of the circle
-
- .. method:: GetCircumference()
-
- Returns the circumference of the circle
-
-
-.. class:: Ellipse2()
- Ellipse2(center, a, b, gamma)
-
- An ellipse is defined by a center, two principal axis and gamma that
- defines the angle between the first principal axis an the x-axis.
-
- .. method:: At(t)
-
- ?
-
- .. method:: AtAngle(angle)
-
- ?
-
- .. method:: GetBoundingBox()
-
- Returns the bounding rectangle (axis-aligned) of the ellipse
-
- :rtype: :class:`Rectangle2`
-
-
- .. method:: GetA()
-
- Returns the first principal-axis
-
- .. method:: GetB()
-
- Returns the second principal-axis
-
- .. method:: GetGamma()
-
- Returns the angle of the first principal axis to the x-axis
-
- .. method:: GetArea()
-
- Returns the area of the ellipse
-
- .. method:: GetOrigin()
-
- Returns the center of the ellipse
-
- .. method:: SetA(a)
-
- Set the length of the first principal axis
-
- .. method:: SetB(b)
-
- Set the length of the second principal axis
-
- .. method:: SetGamma(gamma)
-
- Set the angle of the first principal axis to the x-axis
-
- .. method:: SetOrigin(ori)
-
- Set the center of the ellipse
-
-Geometrical Objects in Three Dimensions
--------------------------------------------------------------------------------
-
-.. class:: Line3()
- Line3(from, to)
-
- Parametric line in three dimensions as defined by an origin and a normalized
- direction vector. The first constructor creates a line with origin (0,0) and
- direction along the x axis. The second signature creates a line originating
- from `from` and pointing towards `to`.
-
- .. method:: At(t)
-
- Returns the point on the line at (signed) distance t from origin.
-
- :param t: free parameter
- :type t: float
- :rtype: :class:`Vec3`
-
-
- .. method:: GetOrigin()
-
- Returns the origin of the line: Also available as :attr:`origin`.
-
- :rtype: :class:`Vec3`
-
- .. method:: GetDirection()
-
- Returns the normalized direction vector. Also available as
- :attr:`direction`.
-
- :rtype: :class:`Vec3`
-
- .. attribute:: direction
-
- :type: :class:`Vec3`
-
- .. attribute:: origin
-
- :type: :class:`Vec3`
-
-.. class:: Plane()
- Plane(p1, p2, p3)
- Plane(x, y, z, p)
- Plane(line, point)
- Plane(point, normal)
-
- A plane in 3d-space. The plane can be constructed by either passing in 3
- points (p1, p2, p3), a normal and a point, the four parameters that define the
- implicit plane equation (`x`, `y`, `z`, `p`) or a line and a point.
-
- .. method:: GetNormal()
-
- Returns the normal of the plane. Also available as :attr:`normal`
-
- :rtype: :class:`Vec3`
-
- .. method:: GetP()
-
- Returns the plane offset, i.e. the projection of any point on the plane onto
- the normal. Also available as :attr:`p`.
-
- :rtype: float
-
- .. method:: GetOrigin()
-
- Get the origin of the plane. Also available as :attr:`origin`.
-
- :rtype: :class:`Vec3`
-
- .. attribute:: origin
-
- :type: :class:`Vec3`
- .. attribute:: normal
-
- :type: :class:`Vec3`
-
- .. attribute:: p
-
- :type: float
-
-
-.. class:: Sphere()
- Sphere(center, radius)
-
- Represents a sphere in 3d space. The first constructor creates a sphere with
- radius 1, centered at (0, 0, 0), the second allows you to set the radius and
- center directly.
-
- :param center: The center
- :type center: :class:`Vec3`
- :param radius: The radius
- :type radius: float
-
- .. attribute:: radius
-
- The radius of the sphere. Read-write. Also available as :meth:`GetRadius`,
- :meth:`SetRadius`.
-
- :type: float
-
- .. attribute:: origin
-
- The center of the sphere. Read-write. Also available as :meth:`GetOrigin`,
- :meth:`SetOrigin`.
-
- :type: :class:`Vec3`
-
- .. method:: GetOrigin()
-
- See :attr:`origin`
-
- .. method:: SetOrigin(origin)
-
- See :attr:`origin`
-
- .. method:: GetRadius()
-
- See :attr:`radius`
-
- .. method:: SetRadius(radius)
-
- See :attr:`radius`
-
-.. class:: AlignedCuboid(min, max)
-
- Axis aligned cuboid is a cuboid whose axes are aligned to the x-, y-, and z-
- axes of the coordinate system. For arbitrarily oriented bounding cuboid
- class, see :class:`Cuboid`.
-
- .. method:: GetMin()
-
- Get minimum coordinate, i.e. the lower bound of x-, y-, and z for
- any point in the cuboid
-
- :rtype: :class:`Vec3`
-
- .. method:: GetMax()
-
- Get maximum coordinate, i.e. the upper bound of x-, y-, and z for
- any point in the cuboid.
-
- :rtype: :class:`Vec3`
-
-.. class:: CuboidAxis()
- CuboidAxis(dir, half_extent)
-
- A cuboid axis is defined by a half-extent, and a direction vector. This class
- is used in together with the :class:`Cuboid` class.
-
- :param dir: Direction vector, will be normalized
- :type dir: :class:`Vec3`
- :param half_extent: The half extent
- :type half_extent: float
-
- .. attribute:: vector
-
- The normalized direction vector of the cuboid axis. Also available as
- :meth:`GetVector`
-
- :type: :class:`Vec3`
-
- .. attribute:: half_extent
-
- The half extent of the cuboid axis is the magnitude of the cuboid
- axis measured from the center to the corner. Also available as
- :meth:`GetHalfExtent`
-
- :type: float
-
- .. attribute:: extent
-
- The extent of the cuboid axis. This value is always twice the
- :attr:`half_extent`. Read-only. Also available as
- :meth:`GetExtent`.
-
- :type: float
-
- .. method:: GetHalfExtent()
-
- See :attr:`half_extent`
- .. method:: GetExtent()
-
- See :attr:`extent`
-
- .. method:: GetVector()
-
- See :attr:`vector`
-
-.. class:: Cuboid(center, axis_a, axis_b, axis_c)
-
- An arbitrarily oriented cuboid defined by a center and 3 axis. The 3 cuboid
- axis are stored in the order they are passed to the constructor. This means,
- that there is no guarantee that the 3 axes form a right-handed coordinate
- system. If a right-handed coordinate system is a requirement, you have to
- ensure this on your own:
-
- .. code-block:: python
-
- center=...
- axis_a=geom.CuboidAxis(...)
- axis_b=geom.CuboidAxis(...)
- axis_c=geom.CuboidAxis(geom.Cross(axis_a.vector, axis_b.vector), ...)
-
- cuboid=geom.Cuboid(center, axis_a, axis_b, axis_c)
-
- :param center: The center
- :type center: :class:`Vec3`
- :param axis_a: The first axis
- :type axis_a: :class:`CuboidAxis`
- :param axis_b: The second axis
- :type axis_b: :class:`CuboidAxis`
- :param axis_c: The third axis
- :type axis_c: :class:`CuboidAxis`
-
- .. attribute:: center
-
- The center of the cuboid.
-
- :type: :class:`Vec3`
-
- .. attribute:: axis_a
-
- The first cuboid axis
-
- :type: :class:`CuboidAxis`
-
- .. attribute:: axis_b
-
- The second cuboid axis
-
- :type: :class:`CuboidAxis`
-
- .. attribute:: axis_c
-
- The third cuboid axis
-
- :type: :class:`CuboidAxis`
-
-Operations on Geometrical Objects
---------------------------------------------------------------------------------
-
-.. function:: Angle(lhs, rhs)
-
- Calculate the angle (in radians) between `lhs` and `rhs`.
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :rtype: float
-
-.. function:: IntersectionPoint(lhs, rhs)
-
- Calculates and returns the intersection point between `lhs` and `rhs`
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :raises: :exc:`GeomException` when the two objects do not intersect
- :rtype: :class:`Vec3` (:class:`Vec2` in case of :class:`Line2`)
-
-.. function:: IntersectionLine(plane2, plane2)
-
- Returns the intersection line between `plane1` and `plane2`.
-
- :param plane1: The first plane
- :type plane1: :class:`Plane`
- :param plane2: The second plane
- :type plane2: :class:`Plane`
-
- :raises: :exc:GeomException if the two planes are parallel.
-
-.. function:: Distance(lhs, rhs)
-
- Returns the minimal distance between `lhs` and `rhs`.
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :rtype: float
-
-.. function:: IsOnLine(line, point, epsilon=geom.EPSILON)
-
- Check whether `point` lies on `line` and returns true if point i no further
- away than `epsilon`.
-
- :rtype: bool
-
-.. function:: IsInPlane(plane, object, epsilon=geom.EPSILON)
-
- Check whether `object` lies in `plane` and returns true if the difference is
- no bigger than `epsilon`.
-
- :param plane: The plane
- :type plane: :class:`Plane`
- :param object: The object
- :type object: :class:`Vec3` or :class:`Line3`
-
- :rtype: bool
-
-.. function:: AreParallel(lhs, rhs, epsilon=geom.EPSILON)
-
- Check whether `lhs` and `rhs` are parallel and returns true, if the difference
- is below the given treshold `epsilon`.
-
- :param lhs: First object
- :type lhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :param rhs: Second object
- :type rhs: :class:`Line2`, :class:`Line3`, :class:`Plane`
-
- :rtype: bool
-
-.. function:: AreIntersecting(line1, line2, epsilon=geom.EPSILON)
-
- Check whether `line1` and `line2` are intersecting and returns true, if they
- intersect below the given threshold `epsilon`.
-
- :param lhs: First line
- :type lhs: :class:`Line2`, :class:`Line3`
-
- :param rhs: Second line
- :type rhs: :class:`Line2`, :class:`Line3`
-
- :rtype: bool
-
-
-
-.. function:: IsInSphere(sphere, point)
-
- Check whether the `sphere` contains `point`.
-
- :rtype: bool
\ No newline at end of file
diff --git a/doc/source/geom/geom.rst b/doc/source/geom/geom.rst
deleted file mode 100644
index d0412a1340ae8ebf248e3193f381801f85d0b05b..0000000000000000000000000000000000000000
--- a/doc/source/geom/geom.rst
+++ /dev/null
@@ -1,16 +0,0 @@
-:mod:`~ost.geom` -- vectors, matrices and geometrical objects
-================================================================================
-
-.. module:: ost.geom
- :synopsis: Functions and classes for vectors, matrices and geometrical
- objects in 2, 3 and four dimensions
-
-The geom modules contains functions and classes for vectors, matrices and other
-geometrical objects in 2, 3 and four dimensions.
-
-
-.. toctree::
-
- vec
- mat
- composite
\ No newline at end of file
diff --git a/doc/source/geom/mat.rst b/doc/source/geom/mat.rst
deleted file mode 100644
index c8736733a7a18533cf18e6fcf40ddecf6b3a52c7..0000000000000000000000000000000000000000
--- a/doc/source/geom/mat.rst
+++ /dev/null
@@ -1,167 +0,0 @@
-Matrices
-================================================================================
-
-.. currentmodule:: ost.geom
-
-The :mod:`~ost.geom` module defines matrices in two, three and four dimensions.
-All matrices store the values in row-major order, meaning that, the matrix ((1,
-2), (3,4)) stores the values as (1, 2, 3, 4). This is illustrated in
-the following code examples:
-
-.. code-block:: python
-
- m=geom.Mat2(1, 2, 3, 4)
- print m # will print {{1,2},{3,4}}
- print m[(0,0)], m[(0,1)], m[(1,0)], m[(1,1)] # will print 1, 2, 3, 4
-
-Matrices support arithmetic via overloaded operators. The following operations are
-supported:
-
- * adding and subtracting two matrices
- * negation
- * multiplication of matrices
- * multiplying and dividing by scalar value
-
-The Matrix Classes
---------------------------------------------------------------------------------
-
-.. class:: Mat2()
- Mat2(d00, d01, d10, d11)
-
- 2x2 real-valued matrix. The first signature creates a new identity matrix. The
- second signature initializes the matrix in row-major order.
-
- .. staticmethod:: Identity()
-
- Returns the 2x2 identity matrix
-
-
-.. class:: Mat3()
- Mat3(d00, d01, d02, d10, d11, d12, d20, d21, d22)
-
- 3x3 real-valued matrix. The first signature creates a new identity matrix. The
- second signature initializes the matrix in row-major order.
-
- .. staticmethod:: Identity()
-
- Returns the 3x3 identity matrix
-
-.. class:: Mat4()
- Mat4(d00, d01, d02, d03, d10, d11, d12, d13, d20, d21, d22, d23, d30, d31, d32, d33)
-
- 4x4 real-valued matrix. The first signature creates a new identity matrix. The
- second signature initializes the matrix in row-major order.
-
- .. method:: ExtractRotation()
-
- Returns the 3x3 submatrix
-
- .. method:: PasteRotation(mat)
-
- Set the 3x3 submatrix of the top-left corner to `mat`
-
- .. method:: ExtractTranslation()
-
- Extract translation component from matrix. Only meaningful when matrix
- is a combination of rotation and translation matrices, otherwise the result
- is undefined.
-
- .. PasteTranslation(trans)
-
- Set the translation component of the matrix to `trans`
-
- :param trans: The translation
- :type trans: :class:`Vec3`
-
- .. staticmethod:: Identity()
-
- Returns the 4x4 identity matrix
-
-Functions Operating on Matrices
---------------------------------------------------------------------------------
-.. function:: Equal(lhs, rhs, epsilon=geom.EPSILON)
-
- Compares the two matrices `lhs` and `rhs` and returns True, if all
- of the element-wise differences are smaller than epsilon. `lhs`
- and `rhs` must be matrices of the same dimension.
-
- :param lhs: First matrix
- :type lhs: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
- :param rhs: Second matrix
- :type rhs: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
-
-.. function:: Transpose(mat)
-
- Returns the transpose of `mat`
-
- :param mat: The matrix to be transposed
- :type lhs: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
-
-.. function:: Invert(mat)
-
- Returns the inverse of `mat`
-
- :param mat: The matrix to be inverted
- :type mat: :class:`Mat2`, :class:`Mat3` or :class:`Mat4`
-
- What happens when determinant is 0?
-
-.. function:: CompMultiply(lhs, rhs)
-
- Returns the component-wise product of `lhs` and `rhs`. `lhs` and
- `rhs` must be vectors of the same dimension.
-
- :param lhs: The lefthand-side vector
- :type lhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
- :param rhs: The righthand-side vector
- :type rhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
-
-.. function:: CompDivide(lhs, rhs)
-
- Returns the component-wise quotient of `lhs` divided by `rhs`. `lhs`
- and `rhs` must be vectors of the same dimension.
-
- :param lhs: The lefthand-side vector
- :type lhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
- :param rhs: The righthand-side vector
- :type rhs: :class:`~Vec2`, :class:`~Vec3` or
- :class:`~Vec4`
-
-.. function:: Det(mat)
-
- Returns the determinant of `mat`
- :param mat: A matrix
- :type mat: :class:`~Mat2`, :class:`~Mat3` or :class:`~Mat4`
-
-.. function:: Minor(mat, i, j)
-
- Returns the determinant of the 2x2 matrix generated from `mat` by
- removing the ith row and jth column.
-
-.. function:: EulerTransformation(phi, theta, xi)
-
- Returns a rotation matrix for the 3 euler angles `phi`, `theta`, and
- `xi`. The 3 angles are given in radians.
-
-
-.. function:: AxisRotation(axis, angle)
-
- Returns a rotation matrix that represents a rotation of `angle`
- around the `axis`.
-
- :param axis: The rotation axis. Will be normalized
- :type axis: :class:`Vec3`
- :param angle: Rotation angle (radians) in clockwise direction when
- looking down the axis.
-
-.. function:: OrthogonalVector(vec)
-
- Get arbitrary vector orthogonal to `vec`. The returned vector is of length
- 1, except when `vec` is a zero vector. In that case, the returned vector is
- (0, 0, 0).
-
- :param vec: A vector of arbitrary length
- :type vec: :class:`Vec3`
\ No newline at end of file
diff --git a/doc/source/geom/vec.rst b/doc/source/geom/vec.rst
deleted file mode 100644
index d3876bcb1f9b46049869a3be84e51bdef9ff7e23..0000000000000000000000000000000000000000
--- a/doc/source/geom/vec.rst
+++ /dev/null
@@ -1,190 +0,0 @@
-Vectors
-================================================================================
-.. currentmodule:: ost.geom
-
-
-The :class:`Vec2`, :class:`Vec3`, :class:`Vec4` classes implement vectors in 2,
-3 and four dimensions. They support basic arithmetic via overloaded operators.
-Essentially, the following basic operations are available:
-
- * adding and subtracting two vectors
- * negation
- * multiplying and dividing by scalar value
-
-This is shown in the following example:
-
-.. code-block:: python
-
- vec_a=geom.Vec2(1, 0)
- vec_b=geom.Vec2(0, 1)
- print vec_a, vec_b
- print vec_a+vec_b
- print vec_a*3-vec_b
-
-The standard vector operations are implemented as :ref:`free standing functions
-<vector-functions>`:
-
-
-.. code-block:: python
-
- vec_a=geom.Vec3(1, 0, 0)
- vec_b=geom.Vec3(0, 1, 0)
-
- print geom.Dot(vec_a, vec_b)
- print geom.Cross(vec_a, vec_b)
-
- print geom.Normalize(geom.Vec3(1, 1, 0))
-
- print geom.Length(geom.Vec3(1, 1, 1))
-
-
-Vector Classes
---------------------------------------------------------------------------------
-.. class:: Vec2([x=0.0, y=0.0, z=0.0])
- Vec2(vec)
-
- Real-valued vector in 2 dimensions.
-
- :param x: x coordinate
- :type x: float or int
- :param y: y coordinate
- :type y: float or int
- :param vec: the coordinates are set to the coordinates of vec. If vec is a
- :class:`Vec2`, the coordinates are copied directly, If vec is a
- :class:`Vec3`, the x and y coordinates are set to the
- coordinates of vec and z is silently swallowed. If vec is of
- type :class:`Vec4`, x and y are divided by the homogenous
- coordinate w, raising a DivideByZeroException when w is zero.
- :type vec: Vec2, Vec3 or Vec4
-
- .. attribute:: x
-
- The x-coordinate of the vector.
-
- :type: float
-
- .. attribute:: y
-
- The y-coordinate of the vector.
-.. class:: Vec3([x=0.0, y=0.0, z=0.0])
- Vec3(vec)
-
- Real-valued vector in 3 dimensions.
-
- :param x: x coordinate
- :param y: y coordinate
- :param z: z coordinate
- :param vec: the coordinates are set to the coordinates of vec. If vec is a
- :class:`Vec3`, the coordinates are copied directly, If vec is a
- :class:`Vec2`, the x and y coordinates are set to the
- coordinates of vec and z is initialized to zero. If vec is of
- type :class:`Vec4`, x, y and z are divided by homogenous
- coordinate w, raising a DivideByZeroException when w is zero.
- :type vec: Vec2, Vec3 or Vec4
-
- .. attribute:: x
-
- The x-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: y
-
- The y-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: z
-
- The z-coordinate of the vector.
-
- :type: float or int
-
-.. class:: Vec4([x=0.0, y=0.0, z=0.0, w=1.0])
- Vec4(vec)
-
- Real-valued vector in 4 dimensions.
-
- :param x: x coordinate
- :type x: float or int
- :param y: y coordinate
- :type y: float or int
- :param z: z coordinate
- :type z: float or int
- :param w: w (homogenous) coordinate
- :type w: float or int
- :param vec: the coordinates are set to the coordinates of vec. If vec is a
- :class:`Vec4`, the coordinates are copied directly, If vec is a
- :class:`Vec2`, the x and y coordinates are set to the
- coordinates of vec and z and w are initialized to 0 and 1,
- respectively. If vec is of type :class:`Vec4`, x, y and z are
- divided by homogenous coordinate w, raising a
- DivideByZeroException when w is zero.
-
- .. attribute:: x
-
- The x-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: y
-
- The y-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: z
-
- The z-coordinate of the vector.
-
- :type: float or int
-
- .. attribute:: w
-
- The homogenous coordinate.
-
- :type: float or int
-
-
-.. _vector-functions:
-
-Functions Operating on Vectors
---------------------------------------------------------------------------------
-
-.. function:: Cross(vec_a, vec_b)
-
- Cross product of `vec_a` and `vec_b`
-
- :type vec_a: Vec3
- :type vec_b: Vec3
-
-.. function:: Dot(vec_a, vec_b)
-
- Dot (scalar) product of `vec_a` and `vec_b`
-
- :param vec_a: first vector
- :type vec_a: Vec3
- :param vec_b: second vector
- :type vec_b: Vec3
-
-.. function:: Length(vec)
-
- Length of vector
-
- :param vec:
- :type vec: Vec2, Vec3 or Vec4
-
-.. function:: Length2(vec)
-
- Returns the squared length of `vec`
-
- :param vec:
- :type vec: Vec2, Vec3 or Vec4
-
-.. function:: Normalize(vec)
-
- Returns a normalized version of `vec`
-
- :param vec: Vector to be normalized
- :type vec: Vec2, Vec3 or Vec4
-
diff --git a/doc/source/gui/100208_OpenStructure_UI_Colored.png b/doc/source/gui/100208_OpenStructure_UI_Colored.png
deleted file mode 100644
index 53338891b594d8dc23e2b9ea509a30c01b5dcb45..0000000000000000000000000000000000000000
Binary files a/doc/source/gui/100208_OpenStructure_UI_Colored.png and /dev/null differ
diff --git a/doc/source/gui/gui.rst b/doc/source/gui/gui.rst
deleted file mode 100644
index 457752167dc7e27f90ecab0c1e74c1d5e9af681a..0000000000000000000000000000000000000000
--- a/doc/source/gui/gui.rst
+++ /dev/null
@@ -1,8 +0,0 @@
-:mod:`~ost.gui` -- Graphical User Interface
-================================================================================
-
-The GUI of OpenStructure is designed to be intuitive, flexible and extensible. Most of the widgets are organized in a big main window which is divided into four parts:
-the main area and three panels containing one or more smaller widgets:
-
-.. image:: images/100208_OpenStructure_UI_Colored.png
-
diff --git a/doc/source/gui/images/100208_OpenStructure_UI_Colored.png b/doc/source/gui/images/100208_OpenStructure_UI_Colored.png
deleted file mode 100644
index 53338891b594d8dc23e2b9ea509a30c01b5dcb45..0000000000000000000000000000000000000000
Binary files a/doc/source/gui/images/100208_OpenStructure_UI_Colored.png and /dev/null differ
diff --git a/doc/source/img/alg/alg.rst b/doc/source/img/alg/alg.rst
deleted file mode 100644
index 3e0f673dedc821d52a781f873d5d21d615f00794..0000000000000000000000000000000000000000
--- a/doc/source/img/alg/alg.rst
+++ /dev/null
@@ -1,67 +0,0 @@
-:mod:`~ost.img.alg` - Image Processing Algorithms
-================================================================================
-
-.. module:: ost.img.alg
- :synopsis: Image processing algorithms
-
-Usage of Image Algorithms
---------------------------------------------------------------------------------
-
-Image algorithms are objects. To execute them, the algorithms are applied to an
-image by passing it to the :meth:`ost.img.ImageHandle.Apply` or
-:meth:`ost.img.ImageHandle.ApplyIP` method:
-
-.. code-block:: python
-
- image=img.CreateImage(img.Size(200, 200))
- fft_image=image.Apply(img.alg.FFT())
- image.ApplyIP(img.alg.FFT())
-
-
-.. class:: FFT
-
- Fast Fourier Transforms the image. The FFT algorithms is aware of the
- image's domain. The following rules apply:
-
- * SPATIAL -> HALF_FREQUENCY
- * HALF_FREQUENCY -> SPATIAL
- * FREQUENCY -> COMPLEX_SPATIAL
- * COMPLEX_SPATIAL -> FREQUENCY
-
-.. class:: GaussianFilter(sigma=1.0)
-
- Applies a gaussian filter to the supplied image. Sigma is given in pixels.
-
- Implemented after I.T.Young, L.J. van Vliet,"Recursive implementation of the
- Gaussian filter", Signal Processing, 44(1995), 139-151
-
-Filters in Fourier Space
---------------------------------------------------------------------------------
-
-The following filters operate in Fourier Space. If the image they are applied on is in spatial domain, they will first be converted to frequency domain and then converted back after the filter has been applied.
-
-.. class:: LowpassFilter(freq_limit)
-
- Filters an image by masking out frequencies higher than
- `freg_limit`.
-
- .. method:: GetLimit()
-
- Returns the frequency limit
-
- .. method:: SetLimit(freq)
-
- Set the frequency limit
-
-.. class:: HighpassFilter
-
- Filters an image by masking out frequences lower than `freq_limit`
-
- .. method:: GetLimit()
-
- Returns the frequency limit
-
- .. method:: SetLimit(freq)
-
- Set the frequency limit
-
\ No newline at end of file
diff --git a/doc/source/img/base/img.rst b/doc/source/img/base/img.rst
deleted file mode 100644
index 53243c9042291e6151667d154c4c411d3a543f8b..0000000000000000000000000000000000000000
--- a/doc/source/img/base/img.rst
+++ /dev/null
@@ -1,186 +0,0 @@
-:mod:`~ost.img` Images and Density Maps
-================================================================================
-
-.. module:: ost.img
- :synopsis: Images and density maps
-
-Introduction : The ImageHandle
---------------------------------------------------------------------------------
-
-OpenStructure offers extensive processing capabilities for planar 2d images and
-3d maps using the img module. Images are manipulated through the use of
-dox[ost::img::ImageHandle|ImageHandles].
-
-ImageHandles provide a clean and efficient interface to interact with images and
-maps. An :class:`ImageHandle` can store an image in either real ('SPATIAL') or
-Fourier ('FREQUENCY') space and always keep track of the currently active
-domain. This means,for example that one can apply a Fourier Transformation to an
-ImageHandle containing a 'SPATIAL' image and the ImageHandle will correctly
-identify the new active domain as 'FREQUENCY'. The ImageHandle also understands,
-for example, that applying a Fourier Transform to a centrosymmetric 'FREQUENCY'
-image results in a real 'SPATIAL' image, but applying it to a
-non-centrosymmetric one results in a complex 'SPATIAL' image.
-
-Furthermore, the ImageHandle will make sure that real and Fourier space
-information about the image are always in sync. If, for example, the pixel
-sampling is changed while the current active domain is real space, the pixel
-sampling in Fourier space will be adjusted accordingly, and vice versa.
-
-Moreover, the ImageHandle allows the extraction of both complex and real numeric
-values from images in any active domain. If the domain is complex in nature, but
-a real numeric value is requested, the amplitude of the complex number will be
-returned. If the numerical nature of the domain is real and a complex number is
-requested, the complex part will be set to 0.
-
-Creating and visualizing ImageHandles
---------------------------------------------------------------------------------
-As a first step, enter the following lines in the OpenStructure python console:
-
- .. code-block:: python
-
- im=img.CreateImage(img.Size(200,200))
-
-This will create an empty, 2D image, with a height and width of 200 pixels, whose
-origin (ie the pixel with the coordinates <0,0>) is in the top-left corner.
-
- .. code-block:: python
-
- v=gui.CreateDataViewer(im)
-
-A viewer window will pop up (see below), showing a white frame on a black background.
-The inner area of the white frame is the image, which is empty.
-
-Reading and writing into an image
--------------------------------------------------------------------------------
-
-Data can be read and written from and into an image using the following commands:
-
- .. code-block:: python
-
- # writes the real value 23.4 into pixel 10,10
- im.SetReal(img.Point(10,10),23.4)
- # reads the value in pixel 10,10
- val=im.GetReal(img.Point(10,10))
-
-The complex equivalents are also available
-
- .. code-block:: python
-
- # writes the complex value value 2+3j into pixel 10,10
- im.SetComplex(img.Point(10,10),2+3j)
- # reads the value in pixel 10,10
- val=im.GetComplex(img.Point(10,10))
-
-The image knows in which domain it is, and will adjust the type of data being written
-accordingly. For example, if one writes a complex value in a 'SPATIAL' image, the value
-will be automatically converted to a real one by taking the amplitude of the complex number
-On the other hand, if one writes a real value in a 'FREQUENCY' image, the value is automatically
-converted to complex by setting the imaginary part to 0.
-
-## Applying algorithms
-
-Let us fill the image with random values.
-
- .. code-block:: python
-
- rand_alg = img.alg.Randomize() # create algorithm object
- im.ApplyIP( rand_alg ) # apply algorithm object in-place
-
-As you can see, applying an algorithm is conceptually a two-step process. First,
-an instance of an algorithm class is created, yielding an algorithm object (in
-this case 'rand\_alg'). In a second step, the algorithm object is applied to an
-image, either in-place, modifying the image, or out-of-place, leaving the
-original image untouched, and returning the result as a new image. Note that the
-in-place/out-of-place logic is decoupled from the algorithm object.
-
-Now that we have some (noisy) data present, let us run another algorithm, this
-time a Gaussian filter with a sigma of 4 pixel.
-
- .. code-block:: python
-
- im.ApplyIP( img.alg.GaussianFilter(4.0) ) # apply temporary algorithm object in-place
-
-As you can see, it is not always necessary to create an independent algorithm
-instance first, in many cases a temporary object will suffice (this applies to
-the randomization algorithm as well, 'im.ApplyIP(alg.Randomize())' would have
-been fine). However, when used this way, the algorithm class will cease to exist
-as soon as the algorithm is applied. This can be important if the algorithm
-stores some values that need to be recovered later. For example:
-
- .. code-block:: python
-
- stat=img.alg.Stat()
- im.ApplyIP(stat)
- mean=stat.GetMean()
-
-Algorithms are stateful objects and can store values. The 'Stat' algorithm
-computes basic statistics about the image it is applied on (maximum and minimum
-values, standard deviations, etc). The data are stored within the algorithm
-instance and can be recovered using the algorithm's methods. It would obviously
-make very little sense not to create an instance of the 'Stat' algorithm. When
-the algorithms ceases to exist, all information would be lost.
-
-Applying a Fourier Transform
---------------------------------------------------------------------------------
-
-An image is Fourier-transformed using the 'img.alg.FFT()' algorithm object:
-
- .. code-block:: python
-
- im=io.LoadImage("imagename.tif") # load the image
- # create an instance of the fft algorithm object
- fft=img.alg.FFT()
- # do the actual Fourier transformation
- im_ft=im.Apply(fft)
- # back-transform
- im2 = im_ft.Apply(fft)
- # if this is run from within the dng graphical frontend, open viewers to
- # look at the images
- gui.CreateDataViewer(im)
- gui.CreateDataViewer(im_ft)
- gui.CreateDataViewer(im2)
-
-It is not really necessary to use the 'fft' variable to store the 'im.alg.FFT()'
-instance, a temporary object can be used, since the 'FFT' algorithm object is stateless. In addition, the algorithm can be applied in-place to avoid the
-creation of a second image:
-
- .. code-block:: python
-
- im=io.LoadImage("imagename.tif") # load the image
- # do the actual Fourier transformation, in-place using temporary object
- im.ApplyIP(alg.FFT())
- # repeating this command will do the back-transform
- im.ApplyIP(alg.FFT())
-
-As said before, the 'alg.FFT()' algorithm does not require a direction to be given, this is implicitly
-determined by the active domain of the underlying image state: a 'SPATIAL' image will always be
-transformed to the 'FREQUENCY' domain, and vice-versa.
-
-Extracting and Pasting Images
---------------------------------------------------------------------------------
-
-An image can be extracted and pasted into another image using the 'Extract()'
-and 'Paste()' member functions:
-
- .. code-block:: python
-
- # load the image
- im=io.LoadImage("imagename.tif")
- # generate a subimage from the region going from (10,10) to (30,30)
- im2=im.Extract(img.Extent(img.Point(10,10),img.Point(30,30)))
- # generate an empty image with the same size as the original image
- im3=img.CreateImage(im.GetExtent())
- # paste the subimage into the empty image
- im3.Paste(im2)
-
-Note that the extent is fully honored for the paste operation, i.e. only the
-region where the pasted-to and the pasted-in image overlap will be affected.
-
-
-
- ..
- | | | |
- |:-------------------------------------------------:|:-------------------------------------------------------------------:|:------------------------------------------------------------------------:|
- |![Empty Image] (docs/tut/dv1.jpg "Empty Image") | ![After Randomization] (docs/tut/dv2.jpg "After Randomization") | ![After Gaussian Filtering] (docs/tut/dv3.jpg "After Randomization") |
- |Empty Image | After Randomization | After Gaussian Filtering |
-
\ No newline at end of file
diff --git a/doc/source/index.rst b/doc/source/index.rst
deleted file mode 100644
index c70e751c08e24eda54a2318c11ac46f829b97810..0000000000000000000000000000000000000000
--- a/doc/source/index.rst
+++ /dev/null
@@ -1,41 +0,0 @@
-OpenStructure documentation
-================================================================================
-
-.. toctree::
- :maxdepth: 2
-
-Introduction
---------------------------------------------------------------------------------
-
-.. toctree::
- :maxdepth: 2
-
- intro
- install
-
-Modules
---------------------------------------------------------------------------------
-
-.. toctree::
- :maxdepth: 2
-
- base/generic
- img/base/img
- img/alg/alg
- geom/geom
- conop/conop
- mol/base/mol
- seq/base/seq
- base/base
- io/io
- gui/gui
-
-Extending OpenStructure
---------------------------------------------------------------------------------
-
-.. toctree::
- :maxdepth: 2
-
- newmodule
- external
-
\ No newline at end of file
diff --git a/doc/source/install.rst b/doc/source/install.rst
deleted file mode 100644
index 86c10f7c515fd9b98f12ebbb595f0fb8b561e053..0000000000000000000000000000000000000000
--- a/doc/source/install.rst
+++ /dev/null
@@ -1,108 +0,0 @@
-Installing OpenStructure
-================================================================================
-
-This document describes how to install OpenStructure from source. If you are not planning to develop code for OpenStructure, you might be better off with one of the binaries available for download.
-
-Installing the Dependencies
---------------------------------------------------------------------------------
-
-OpenStructure uses a bunch of OpenSource libraries. If you haven't already installed them, please install them now!
-
- * `CMake <http://cmake.org>`_
- * `Eigen2 <http://eigen.tuxfamily.org>`_
- * `Boost <http://boost.org>`_
- * `libpng <http://www.libpng.org>`_
- * `Python <http://python.org>`_
- * `Qt <http://qt.nokia.com>`_
-
-When you enable support for image processing, you will need:
-
- * `FFTW3 <http://fftw.org>`_. By default, OpenStructure is compiled with single precision and thus also requires FFTW to be compiled with single precision. Most platforms offer this as a second package. If you are compiling manually, use the `--enable-single` option.
-
- * `libtiff <http://www.libtiff.org>`_
-
-
-
-If you would like to use the graphical user interface, also install:
-
- * `SIP <http://www.riverbankcomputing.co.uk/software/sip/download>`_.
- * `PyQt4 <http://www.riverbankcomputing.co.uk/software/pyqt/download>`_.
-
-In case you are compiling under Windows you have to install `Visualstudio
-2008 <http://www.microsoft.com/express/Downloads>`_. to compile the dependecies
-and OpenStructure. We recommend to compile the dependecies manually. Enter the
-directories where the dependencies are located in Tools->Options->Projects and
-Solutions->VC++ directories. Choose 'bin' directories to enter program paths to
-cmake, qmake and python, 'lib' directories to point to the location(s) of your
-dependencies.
-
-Checking out the Source
---------------------------------------------------------------------------------
-
-You can checkout the source from SVN. The repository is located at
-
- https://dng.biozentrum.unibas.ch/svn/openstructure/trunk
-
-If you are using the commandline client, type in your shell
-
- svn co https://ost.biozentrum.unibas.ch/svn/openstructure/trunk
-
-On Windows install svn clients like `tortoisesvn <http://tortoisesvn.tigris.org>`_ and use the function 'checkout' then enter the above mention URL.
-
-
-Configuring
---------------------------------------------------------------------------------
-
-
-OpenStructure uses `CMake <http://cmake.org>`_ for compiling and building the project. The next required step is to configure the build environment using cmake. You can do that by invoking `cmake` in the project directory (On Windows choose Tools->visualstudio commandline prompt from within visualstudio) :
-
- cmake . <options>
-
-There are two kinds of options: Options that let you control the building behaviour, enabling and disabling the compilation of certain modules and options that let you tell CMake where to find the dependencies. All of them are passed to CMake with via `-D<opt>=<value>`.
-
-Flag to choose build system
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-On Windows make sure you specify -G"Visual Studio 9 2008"!
-
-Flags to Control the Dependencies
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-By default, `CMake <http://cmake.org>`_ searches the standard directories for dependencies. However, on some systems, this might not be enough. Here is a short description of how CMake figures out what dependencies to take and how you can influence it.
-
- * Boost is mainly controlled via the `BOOST_ROOT` option. If boost wasn't
- found, it should be set to the prefix of the boost installation.
-
- * `QT_QMAKE_EXECUTABLE` defines the exact Qt installation to take. It should
- be set to the full path to `qmake`.
-
- * `PYTHON_ROOT` is the Python equivalent of BOOST_ROOT. It should be set to
- the prefix path containing the python binary, headers and libraries.
-
- * `SYS_ROOT` controls the general prefix for searching libraries and headers.
- By default, it is set to `/`.
-
-Build Options
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
- * `ENABLE_UI` controls whether to build the graphical user interface module. By
- default it is set to true.
- * `ENABLE_IMG` controls whether to build the image processing module. This will
- enable support for density maps, and general image processing in 1, 2 an 3
- dimensions. By default it is set to true.
-
- * `ENABLE_GFX` controls whether to build the graphics module. By default, this
- is set to true. If set to none, this implies `ENABLE_UI=NO`.
-
- * Shader support is controlled with `USE_SHADER`. By default, no shaders are
- used.
-
- * If `OPTIMIZE` is set to 1, an optimized version of OpenStructure is built.
-
-Building the Project
---------------------------------------------------------------------------------
-
-Type `make`. If you are using a multi-core machine, you can use the `-j` flag to run
-multiple jobs at once.
-
-On Windows run 'Build OpenStructure' from the build menu.
diff --git a/doc/source/intro.rst b/doc/source/intro.rst
deleted file mode 100644
index abf6e6cf9fe1ac349a9af1a8d5fd63c686bf14b9..0000000000000000000000000000000000000000
--- a/doc/source/intro.rst
+++ /dev/null
@@ -1,368 +0,0 @@
-A gentle introduction to OpenStructure
-================================================================================
-
-In this tutorial you will be learning by example how to use the OpenStructure
-framework.
-
-We assume that you already have a version of OpenStructure installed. If not,
-please refer to :doc:`install`.
-
-
-What will be covered in this tutorial?
---------------------------------------------------------------------------------
-
-This tutorial is aimed at users that would like to get their hands dirty and
-execute commands in Python and write scripts rather clicking their way through a
-shiny user interface. The user interface of OpenStructure is in a very early
-state anyway that you probably won't go far by clicking you way through...
-
-The first part of the tutorial is a walk-through of the basic functionality you
-will be using in your everyday work. You will learn how to load structure
-datasets, inspect, display them in the 3D window and save them.
-
-
-Getting ready to rumble
---------------------------------------------------------------------------------
-
-The files we will be using in the tutorial are available in the examples folder
-that comes with OpenStructure. Depending on your platform, the examples are
-located at a different location:
-
- * on *MacOS X* the files are in /Applications/OpenStructure/Examples
- * on *Linux* and *Windows* PREFIX/share/openstructure/examples, where PREFIX is
- the path to the directory containing OpenStructure.
-
-Starting DNG
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The graphical user interface of OpenStructure is called DNG (Dino/DeepView Next
-Generation). To start it,
-
- * on *MacOS X* double click DNG.app in /Applications/OpenStructure
- * on *Windows* double click dng.bat inside the PREFIX/bin directory
- * on *Linux* fire up a terminal change into the OpenStructure installation
- directory and type 'bin/dng'. If you have the binary directory in the PATH,
- typing dng is sufficient.
-
-Interactive Python Shell
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Now we will enter commands in the Python Shell (in the screenshot above, the
-python shell is located at the bottom of the main window). If you want to get
-more information on any object, function or class, the python help command may
-be useful. For example:
-
- .. code-block:: python
-
- # get list of methods of EntityView
- help(mol.EntityView)
- # get help for method Select
- help(mol.EntityView.Select)
-
-Loading and inspecting a protein structure
---------------------------------------------------------------------------------
-
-OpenStructure has a module that is dedicated to deal with input and output of
-data, including sequence alignment formats, protein structures and density data
-and images. If you are reading this tutorial you most certainly have dealt with
-protein structures before and you are most certainly aware that they are usually
-stored in Brookhaven structure files (aka PDB files). The official name for
-molecules stored in a PDB file is an entity. You will hear this word all the
-time, but you can replace the word entity with molecule in your head.
-
-
-To load a PDB file, type
-
- .. code-block:: python
-
- fragment=io.LoadPDB('/path/to/examples/entity/fragment.pdb')
-
-This will load the fragment from the specified file 'fragment.pdb' and store the result in fragment. For more information on the LoadPDB function, type
-
- .. code-block:: python
-
- help(io.LoadPDB)
-
-Now let's inspect what we just loaded:
-
- .. code-block:: python
-
- print fragment.chain_count
- print fragment.residue_count
- print fragment.atom_count
-
-As you can see, our fragment consists of one peptide chain of 12 amino acids and
-has 81 atoms in total. Now let's examine our fragment in more detail. Enter the
-command
-
- .. code-block:: python
-
- for residue in fragment.residues:
- print residue
-
-This will print a list of all residues in the fragment. Similarly to get a list
-of atoms, use:
-
- .. code-block:: python
-
- for atom in fragment.atoms:
- print atom
-
-Of course, we can also get a list of atoms grouped by residues:
-
- .. code-block:: python
-
- for residue in fragment.residues:
- print residue, 'has', residue.atom_count, 'atom(s).'
- for atom in residue.atoms:
- print ' ', atom.name, atom.pos
-
-And, for completeness, we will first group them by chain, then by residues.
-
- .. code-block:: python
-
- for chain in fragments.chains:
- print 'chain', chain.name, 'has', chain.residue_count, 'residue(s)'
- for residue in chain.residues:
- print ' ', residue, 'has', residue.atom_count, 'atom(s).'
- for atom in residue.atoms:
- print ' ', atom.name, atom.pos
-
-Aah, wait! A protein fragment would not be complete without bonds: Let's see
-what bonds we have in there:
-
- .. code-block:: python
-
- for bond in fragment.bonds:
- print bond
-
-From these short code examples we already see how the entity is structured: On
-one hand we have a hierarchy of chains, residues and atoms. On the other hand,
-we have bonds that form a network overlayed on the hierarchy. This is
-illustrated in the picture on the left. An important feature of entities is that
-we can always assume that the hierarchy is intact. You will never find an atom
-without residues, no residue can exist without a parent chain and chains belong
-always to an entity.
-
-Let There Be Shiny Graphics
---------------------------------------------------------------------------------
-
-For visually inspecting the fragment, we now create a graphical representation
-of the entity:
-
- .. code-block:: python
-
- go=gfx.Entity("Fragment", fragment)
- scene.Add(go)
- scene.CenterOn(go)
-
-Now you will see the fragment in the 3D window (left):
-
-
-
-Use the mouse to rotate, zoom in an shift the camera. Double clicking on an atom will center the camera on that atom.
-
-Introduction to Views
---------------------------------------------------------------------------------
-
-Often during processing and visualisation of data, only parts of a protein
-structure are of interest. This realisation has had a major impact on the design
-of OpenStructure and is tied very deeply into the core of the framework.
-Subparts of structure are modeled as so-called :class:`EntityViews
-<mol.EntityView>`. You can think of them as a selection of chains, residues,
-atoms and bonds of an entity. A views has almost the same interface as the
-underlying entity, making it very easy to mix entity views with handles in
-Python due to the dynamic nature of the language. An algorithm that is written
-for entities will almost always (with some care) also work for
-:class:`EntityHandles <mol.EntityHandle>`. This is referred to as `duck-typing
-<http://en.wikipedia.org/wiki/Duck_typing>`_ (I don' t care if it is a duck as
-long as it looks like a duck), a concept used all over the place in Python.
-
-A typical view can be seen in the image on the left. The view consists of one
-chain, one residue and two atoms. Again the same rule applies: No atom can be
-part of the view without it's residue. In this example, no bonds are included,
-since there is at most one atom per bond in the original structure.
-
-To familiarize yourself with the concept of views, we will use the fragment in
-the 3D window.
-
-We will use several ways to select parts of our fragment:
- * By using a dedicated query language
- * By manually constructing a view
-
-The Query Language
---------------------------------------------------------------------------------
-
-The first way to select parts of a structure is with a dedicated mini-language,
-called ["the query language”](docs/tut/query.html). In the Python Shell, type
-
- .. code-block:: python
-
- go.selection=fragment.Select('')
-
-A green halo will be displayed around the selected parts (image in the middle).
-
-As you can see the previous statement created a “full view”, containing all the
-chains, residues, atoms and bonds. To select lysine residues, type
-
- .. code-block:: python
-
- go.selection=fragment.Select('rname=LYS')
-
-
-As you can see (image in the middle), the only lysine residue is now
-highlighted in the 3D window, because it was the only one matching the predicate
-"residue name must be equal to LYS". Several such predicates can be combined
-with boolean operators such as *and* and *or*. To select residues with residue
-number 1 to 3, the following statement will do the job:
-
- .. code-block:: python
-
- go.selection=fragment.Select('rnum>=1 and rnum<=3')
-
-but this is very cumbersome. That's why there is a shortcut to this statement.
-You can specify a range of values.
-
- .. code-block:: python
-
- go.selection=fragment.Select('rnum=1:3')
-
-For a complete description of what you can do with the query language, have a
-look at the :doc:`../mol/base/query`.
-
-
-Constructing Views Manually
---------------------------------------------------------------------------------
-
-Sometimes the query language Is Not Enough (TM). For these cases the
-construction of manual entities becomes neccessary. This is pretty straight
-forward:
-
- .. code-block:: python
-
- view=fragment.CreateEmptyView()
- ca=fragment.FindAtom('A', mol.ResNum(1), 'CA')
- cb=fragment.FindAtom('A', mol.ResNum(1), 'CB')
- view.AddAtom(ca)
- view.AddAtom(cb)
- go.SetSelection(view)
-
-The last step sets our constructed view as the current selection, displaying it
-in the 3D window. As you can see, C-alpha and C-beta of the first residue are
-not connected by bonds, even though both atoms are in the view. You have either
-to add the bond manually with
-
- .. code-block:: python
-
- ca_cb=ca.FindBondToAtom(cb)
- view.AddBond(ca_cb)
-
-Or as a very convenient shortcut 'view.AddAllInclusiveBonds()' to add all bonds
-that have both bonding partners in the view.
-
-Don't forget to call update the selection of the graphics object to see what
-view you have created.
-
-Saving an Entity
---------------------------------------------------------------------------------
-
-Saving an entity (or a view) is a breeze:
-
-Type
-
- .. code-block:: python
-
- io.SavePDB(fragment, 'full.pdb')
-
-to save the full view. To save only the backbone atoms, we can first select the
-backbone atoms and then save it:
-
- .. code-block:: python
-
- io.SavePDB(fragment.Select('aname=CA,C,N,O'), 'backbone.pdb')
-
-
-Loading images and density maps
---------------------------------------------------------------------------------
-
-Openstructure features a :mod:`~ost.img` module that is dedicated to the
-manipulation of
-images/density maps. The images or density maps can either be one-, two- or
-three-dimensional. The most common formats used in x-ray and electron
-crystallography and atomic force microscope are supported in addition to several
-general purpose image formats. See `supported file formats` for details.
-The :mod:`~ost.img` module was originally developed as part of the Image
-Processing Library & Toolbox IPLT. More documentation and examples can also be
-found on the `IPLT website <http://www.iplt.org>`_.
-
-To load a density map, type
-
- .. code-block:: python
-
- map=io.LoadImage('/path/to/examples/map/1ppt.map')
-
-This will load the fragment density map from the specified file 'fragment.map'
-and store the result in fragment_map.
-
-Now let's inspect what we just loaded:
-
- .. code-block:: python
-
- print map.GetPixelSampling()
-
-We can see that the sampling is set to 1.0 Angstroems in all three dimensions.
-
-Manipulating images and density maps
---------------------------------------------------------------------------------
-
-The algorithms used for manipulation of an image are found in the
-:mod:`~ost.img` module. Therefore before using an algorithm we first have to
-import the :mod:`~ost.img` module.
-
- .. code-block:: python
-
- from ost import img
-
-
-The :mod:`~ost.img` module provides a wide range of algorithm to manipulate
-image data. Here for the example we use a LowPassFilter to restrict the
-resolution of the density map.
-
- .. code-block:: python
-
- map_filtered=map.Apply(img.alg.LowPassFilter(3.0))
-
-The filtered map is stored in a new variable called fragment\_map\_filtered.
-
-
-Displaying images and density maps
---------------------------------------------------------------------------------
-
-Now that we have a filtered map it's time to have a look at it. There are
-fundamentally two ways to visualize 3-dimensional density maps. One is by
-drawing isosurfaces. These are conceputally similar to contour lines used in
-cartography: every point on an isosurface has the same density value.
-Isosurfaces are easy to create in OpenStructure:
-
- .. code-block:: python
-
- go=gfx.MapIso("filtered", map_filtered,0.5)
- scene.Add(go)
-
-The other way to visualize a 3-dimensional map is by showing one 2-dimensional
-density slice at a time, allowing the user to move through the slices. In
-OpenStructure this is achieved using a DataViewer docs/tut/imgdataviewer.html).
-A DataViewer showing the filtered map is created using the following command:
-
- .. code-block:: python
-
- gui.CreateDataViewer(map_filtered)
-
-This command displays a panel showing one slice of the density map lying on a
-particular (x,y) plane in the coordinate reference system.
-The 'z' and 'x' keys can be used to move to slices lying at a lower or higher
-coordinate along the 'z' axis, allowing the examination of
-the full 3-dimensional volume.
-
-A more detailed explanation of the :mod:`~ost.img` module can be found in the
-tutorial section for :mod:`~ost.img`.
diff --git a/doc/source/io/formats.rst b/doc/source/io/formats.rst
deleted file mode 100644
index ceef7e5f25111f28e50c66a966fdacf6d621bc61..0000000000000000000000000000000000000000
--- a/doc/source/io/formats.rst
+++ /dev/null
@@ -1,81 +0,0 @@
-Supported File Formats
-================================================================================
-
-Structure File Formats
---------------------------------------------------------------------------------
-
-The following file formats are supported by :func:`~ost.io.LoadEntity`.
-
-
-
-PDB - Brookhaven PDB File
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-Fine grained control over PDB file import is available via the
-:func:`~ost.io.LoadPDB` function. The PDB importer support loading gzipped PDB
-files. gzipped PDB files are detected by the .gz file extension.
-
-*Recognized File Extensions*
- ent, pdb, ent.gz, pdb.gz
-
-*Format Name*
- pdb
-
-PQR
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- pqr
-
-*Format Name*
- pqr
-
-CRD - CARD format file used by CHARMM
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- crd
-
-SDF
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- sdf
-
-Sequence File Formats
---------------------------------------------------------------------------------
-
-FASTA
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- fasta, fna, fas, fa, fsa
-
-*Format Name*
- fasta
-
-ClustalW
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- aln
-
-*Format Name*
- clustal
-
-Promod
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- ali
-
-*Format Name*
- promod
-
-PIR
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-*Recognized File Extensions*
- pir
-
-*Format Name*
- pir
\ No newline at end of file
diff --git a/doc/source/io/io.rst b/doc/source/io/io.rst
deleted file mode 100644
index 21c38bc4f93f2ce10b4357004c9c688f310a178a..0000000000000000000000000000000000000000
--- a/doc/source/io/io.rst
+++ /dev/null
@@ -1,103 +0,0 @@
-:mod:`~ost.io` - Input and Output of Sequences, Structures and Maps
-================================================================================
-
-.. module:: ost.io
- :synopsis: Input and output of sequences, structures and density maps
-
-The io module deals with input and output of :class:`entities
-<ost.mol.EntityHandle>`, :class:`alignments <ost.seq.AlignmentHandle>`, and
-:class:`images <ost.img.ImageHandle>`. Importers for common file formats such
-as PDB, SDF, FASTA, CLUSTAL W, DX and CHARMM trajectory files are available.
-
-Molecular Structures
---------------------------------------------------------------------------------
-
-Loading Molecular Structures
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The :mod:`~ost.io` modules offers several ways to load molecular structures
-depending on your requirements. The most general way is offered by
-:func:`~ost.io.LoadEntity`, which will automatically detect the file format based
-on the file extension.
-
-.. function:: LoadEntity(filename, format='auto')
-
- Load entity from disk. If format is set to 'auto', the function guesses the
- filetype based on the extension of the file. Files ending in '.pdb', '.ent',
- '.ent.gz', '.pdb.gz' will automatically be loaded as PDB files, for example.
- For files without or exotic extensions, the format can be set explicitly as
- the second parameter.
-
- .. code-block:: python
-
- # recognizes SDF file by file extension
- ent=io.LoadEntity('file.sdf')
-
- # In this case, there is no file extensions, so you have to say it's a
- # SDF file explicitly
- ent=io.LoadEntity('file', 'sdf')
-
- For a list of file formats supported by :func:`LoadEntity`, see :doc:`formats`.
-
- :raises: :exc:`~ost.io.IOUnknownFormatException` if the format string supplied
- is not recognized or the file format can not be detected based on the
- file extension
-
- :exc:`~ost.io.IOException` if the import fails due to an erroneous or
- inexistent file
-
-Some of the formats have a dedicated function that allows you to tweak many
-parameters that affect the import. PDB files can be loaded with
-:func:`~ost.io.LoadPDB`. It offers a tighter control over the exact loading
-behaviour.
-
-.. autofunction:: ost.io.LoadPDB
-
-
-Saving Molecular Structures
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Saving a complete entity or a view is a matter of calling
-:func:`~ost.io.SaveEntity`.
-
-.. code-block:: python
-
- ent=io.LoadEntity('protein.pdb')
- # save full entity
- io.SaveEntity(ent, 'full.pdb')
- # only save C-alpha atoms
- io.SaveEntity(ent.Select('aname=CA and peptide=true'), 'calpha.pdb')
-
-:func:`~ost.io.SavePDB` provides a simple way to save several entities into one
-file:
-
-
-.. code-block:: python
-
- ent=io.LoadEntity('protein.pdb')
- # Save complete entity
- io.SavePDB(ent, 'full.pdb')
- # Save chain A and chain B separately
- io.SavePDB([ent.Select('cname=A'), ent.Select('cname=B')], 'split.pdb')
-
-
-.. function:: SaveEntity(ent, filename, format='auto')
-
- Save entity to disk. If format is set to 'auto', the function guesses the
- filetype based on the file extension, otherwise the supplied format is checked
- against the available export plugins.
-
- :param ent: The entity to be saved
- :type ent: :class:`~ost.mol.EntityHandle` or :class:`~ost.mol.EntityView`
- :param filename: The filename
- :type filename: string
- :param format: Name of the format
- :type format: string
-
- :raises: :exc:`~ost.io.IOUnknownFormatException` if the format string supplied
- is not recognized or the file format can not be detected based on the
- file extension
-
-.. autofunction:: ost.io.SavePDB
-
-
\ No newline at end of file
diff --git a/doc/source/mol/base/editors.rst b/doc/source/mol/base/editors.rst
deleted file mode 100644
index f224b2e1fd2290db8be073dda9d18fc36bf052db..0000000000000000000000000000000000000000
--- a/doc/source/mol/base/editors.rst
+++ /dev/null
@@ -1,151 +0,0 @@
-Editors
-================================================================================
-
-.. currentmodule:: ost.mol
-
-The structure, topology and connectivity of entities is edited via editors. This
-includes operations such as changing atom positions, connecting atoms with bonds
-as well as adding and removing chains, residues and atoms.
-
-Edit Modes
---------------------------------------------------------------------------------
-
-Editors support two modes: An unbuffered edit mode and a buffered edit mode. In
-the unbuffered edit mode, dependent information such as the spatial organizer
-and the internal coordinate system (in case of the XCSEditor) are updated after
-every change. In buffered edit mode, the updates are delayed until one of the
-following happens:
-
- * The last editor goes out of scope.
- * :meth:`XCSEditor.UpdateICS` or :meth:`ICSEditor.UpdateXCS` is called
- explicitly.
-
-
-The editors follow the RIAA (resource allocation is initialisation) principle:
-Whenever an editor is requested an internal reference counter is incremented. In
-the destructor, this reference count is decremented. When the count drops to
-zero, the dependent infomation is updated.
-
-In Python, one can not rely on the destructors being called. It is adviced to
-always put a call to :meth:`XCSEditor.UpdateICS` or
-:meth:`ICSEditor.UpdateXCS` when the editing is finished. Alternatively, starting from Python version 2.6, one can use the
-`with <http://docs.python.org/reference/compound_stmts.html#with>`_ statement
-to make sure the destructor are called and the dependent information is updated.
-
-
-Basic Editing Operations
---------------------------------------------------------------------------------
-
-The basic functionality of editors is implemented in the EditorBase class.
-
-.. class:: EditorBase
-
- Inherited by :class:`XCSEditor`, :class:`ICSEditor`.
-
- .. method:: InsertChain(chain_name)
-
- Add new chain to the entity
-
- :param chain_name: The chain's name. In the scope of an entity, chain names
- are unique. If a chain of the same already exists an
- IntegrityError is raised.
- :type chain_name: string
- :returns: :class:`ChainHandle`
-
- .. method:: AppendResidue(chain, residue_name, [res_num])
-
- Append residue to the end of the chain. If res_num is not given, the
- residue number will be set to the residue number of the last added residue
- plus one. The insertion code is the same.
-
- :param chain: Must be a valid chain
- :type chain: :class:`ChainHandle`
- :param residue_name: 3-letter-code of the residue, e.g. ``GLY``.
- :type residue_name: string
- :returns: :class:`ResidueHandle`
-
- .. method:: InsertAtom(residue, atom_name, pos, [prop=mol.AtomProp()])
-
- Insert new atom and add it to residue. For atoms with alternative atom
- locations use :meth:`InsertAltAtom`.
-
- :param residue: is the parent residue and must be valid
- :type residue: :class:`ResidueHandle`
- :param atom_name: is the atom name. While free to choose a name, it is
- adviced to properly name the atoms according to IUPAC
- rules as several algorithms as well as most
- :class:`builders <conop.Builder>` in the :mod:`conop`
- module rely on proper naming.
- :type atom_name: string
- :param pos: is the position of the atom in global coordinates
- :type pos: :class:`geom.Vec3`
- :param prop: are the atom's properties such as element, van der Waals
- radius charge and so on. The default set of atom
- properties is rather meaningless.
- :type prop: class:`AtomProp`
- :returns: :class:`AtomHandle`
-
-Editor for the External Coordinate System
---------------------------------------------------------------------------------
-
-The XCSEditor defines the interface for manipulating the external coordinate
-system. The external coordinate system directly operates on atom positions in
-euclidian space.
-
-.. class:: XCSEditor
-
- Inherits :class:`EditorBase`
-
- .. method:: ApplyTransform(transform)
-
- Apply a transformation the entity transform. The entity transform is a
- global transformation applied to all atoms.
-
- :param transform: The transformation to be applied
- :type transform: :class:`geom.Mat4`
-
- .. method:: SetTransform(transform)
-
- Set the entity transformation. See also :meth:`ApplyTransform`
-
- :param transform: The transformation to be applied
- :type transform: :class:`geom.Mat4`
-
- .. method:: SetAtomPos(atom, pos)
-
- Set the (transformed) position of atom. This method will also update the
- original position of the atom by applying the inverse of the entity
- transform.
-
- :param atom: must be a valid atom handle
- :type atom: :class:`ost.mol.AtomHandle`
- :param pos: The new position
- :type pos: :class:`geom.Vec3`
-
- .. method:: SetOriginalAtomPos(atom, pos)
-
- Set the origininal (untransformed) position of the atom. This method will
- also update the transformed position by applying the entity transform to
- the original pos.
-
- :param atom: must be a valid atom handle
- :type atom: :class:`ost.mol.AtomHandle`
- :param pos: The new untransformed position
- :type pos: :class:`geom.Vec3`
-
-Editor for the Internal Coordinate System
---------------------------------------------------------------------------------
-The :class:`ICSEditor` is used to manipulate the internal coordinate system that
-is defined by bond lengths and angles. By default the internal coordinate system
-is not calculates. However, upon requesting an :class:`ICSEditor` for the first
-time, the internal coordinate system is initialized. This involves the build-up
-of a directed-graph for the bond network as well as calculating the internal
-coordinate matrices.
-
-The use :class:`XCSEditor` and :class:`ICSEditor` are mutually exclusive. This
-means that whenever a :class:`XCSEditor` has pending changes, the results of
-using an :class:`ICSEditor` is undefined and vice versa.
-
-.. class:: ICSEditor
-
- Inherits :class:`EditorBase`
diff --git a/doc/source/mol/base/entity.rst b/doc/source/mol/base/entity.rst
deleted file mode 100644
index 1adcd2de76af8d919b0928bc91b01669912a1a59..0000000000000000000000000000000000000000
--- a/doc/source/mol/base/entity.rst
+++ /dev/null
@@ -1,332 +0,0 @@
-The Molecular Entity
-================================================================================
-
-.. currentmodule:: ost.mol
-
-This document describes the :class:`EntityHandle` and related classes.
-
-
-.. function:: CreateEntity()
-
- Creates a new entity. The created entity is empty, that is, it does not
- contain any atoms, residues, chains, bonds or torsions. To populate the
- entity, use an :doc:`editors`.
-
- :returns: The newly created :class:`EntityHandle`
-
-.. class:: EntityHandle
-
- The entity class represents a molecular structure. Such a structure is in
- general made up of one or more linear chains of residues, which in turn are
- formed by one or more atoms.
-
- The interface of entities is tailored to biological macromolecules, but this
- does not prevent it to be used for molecules in general: An entity also
- represent a ligand or a collection of water molecules - hence the rather
- generic name.
-
- .. method:: FindChain(chain_name)
-
- Get chain by name. See also :meth:`GetChainList`
-
- :param chain_name: Chain identifier, e.g. "A"
- :type chain_name: string
- :returns: A valid :class:`ChainHandle`, if the entity contains a
- chain with the given name, an invalid
- :class:`ChainHandle` otherwise.
-
- .. method:: GetChainList()
-
- Get list of all chains of this entity. To access a single chain, use
- :meth:`FindChain`.
-
- :returns: A list of :class:`ChainHandles<ChainHandle>`
-
- .. method:: FindResidue(chain_name, res_num)
-
- Get residue by chain name and residue number. See also
- :meth:`GetResidueList`
-
- :param chain_name: Chain identifier, e.g. "A"
- :type chain_name: string
- :param res_num: residue number
- :type res_num: mol.ResNum
-
- :returns: A valid :class:`ResidueHandle` if the chain exists and
- the chain contains a residue of the given residue
- number, an invalid :class:`ResidueHandle` otherwise.
-
- .. method:: GetResidueList()
-
- Get list of all residues of this entity. To access a single residue, use
- :meth:`FindResidue`.
-
- :returns: A list of :class:`ResidueHandles<ResidueHandle>`
-
- .. method:: FindAtom(chain_name, res_num, atom_name)
-
- Get atom by chain name, residue number and atom name. See also
- :meth:`GetAtomList`
-
- :param chain_name: Chain identifier, e.g. "A"
- :type chain_name: string
- :param res_num: residue number
- :type res_num: mol.ResNum
- :param atom_name: atom name, e.g. CA
- :type atom_name: string
-
- :returns: A valid :class:`AtomHandle` if an atom matching the
- parameters could be found, an invalid
- :class:`AtomHandle` otherwise
-
- .. method:: GetAtomList()
-
- Get list of all atoms of this entity. To access a single atom, use
- :meth:`FindAtom`
-
- :returns: A list of :class:`AtomHandles<AtomHandle>`
-
- .. method:: RequestXCSEditor([edit_mode=mol.EditMode.BUFFERED_EDIT])
-
- Request :class:`XCSEditor` for editing the external coordinate system. This
- call will fail when there are pending changes of the internal coordinate
- system.
-
- :param edit_mode: Must be EditMode.BUFFERED_EDIT or
- EditMode.UNBUFFERED_EDIT. For more details, see the
- editor documentation.
- :type edit_mode: mol.EditMode
-
- :returns: :class:`XCSEditor`
- .. method:: RequestICSEditor([edit_mode=mol.EditMode.BUFFERED_EDIT])
-
- Request :class:`ICSEditor` for editing the internal coordinate system, such
- as torsions, bond lengths and angle between two bonds. This call will fail
- when there are pending changes of the external coordinate system.
-
- :param edit_mode: Must be EditMode.BUFFERED_EDIT or
- EditMode.UNBUFFERED_EDIT. For more details, see the
- editor documentation.
- :type edit_mode: mol.EditMode
-
- :returns: :class:`ICSEditor`
-
- .. method:: Select(query, flags)
-
- Perform a selection on the entity. The result of the selection is an
- :class:`EntityView` which contains usually only a subset of chains,
- residues, atoms and bonds of the original entity.
-
- :param query: The query to be executed. See :class:`Query` for details.
- :type query: string or :class:`Query`
- :param flags: An ORed combination of :class:`QueryFlags`.
- :type flags: int
- :returns: An :class:`entity view <EntityView>`.
- :raises: :class:`QueryError` when the query could not be executed due
- to syntactic errors.
-
- .. method:: CreateFullView()
-
- Creates an entity view containing all chains, residues, atoms and bonds of
- this entity.
-
- .. code-block:: python
-
- # these two lines are identical
- full=ent.Select('')
- full=ent.CreateFullView()
-
- :returns: :class:`EntityView`
-
- .. method:: CreateEmptyView()
-
- Creates an entity view pointing to this entity, but otherwise empty. This
- method is usually the starting point for manual entity view creation, e.g.
-
- .. code-block:: python
-
- view=ent.CreateEmtpyView()
- for atom in ent.atoms:
- if ComplicatedPredicate(atom):
- view.AddAtom(atom)
-
- :returns: :class:`EntityView`
-
- .. method:: Copy()
-
- Creates a deep copy of the entity.
-
- :returns: A new :class:`EntityHandle` that is an exact copy of this entity.
-
- .. note::
-
- alternative atom positions are not handled yet.
-
- .. method:: GetCenterOfAtoms()
-
- Get center of atoms, that is the average atom position of the entity. Use
- :meth:`GetCenterOfMass` to calculate the mass-weighted center of the entity.
-
- :returns: :class:`geom.Vec3`
-
- .. method:: GetCenterOfMass()
-
- Calculates the center of mass of the entity. Use :meth:`GetCenterOfAtoms`
- to calculate the non-mass-weighted center of the entity.
-
- :returns: :class:`geom.Vec3`
-
- .. method:: GetGeometricCenter()
-
- Calculates the mid-point of the axis aligned bounding box of the entity.
-
- :returns: :class:`geom.Vec3`
-
- .. method:: GetMass()
-
- Calculates the total mass of the entity by summing up the masses of all
- atoms.
-
- :returns: The mass in Dalton
-
- .. method:: Apply(visitor)
-
- Apply EntityVisitor to the entity. In Python, you shouldn't bother using
- this function. EntityVisitory are mainly used in C++ to implement
- algorithms that operate are able to operate on EntityViews or
- EntityHandles.
-
- .. method:: FindWithin(pos, radius)
-
- Find all atoms in sphere of given radius centered at *pos*. To turn the
- returned list of atoms into an :class:`EntityView`, use
- :func:`CreateViewFromAtomList`.
-
- :param pos: Center of sphere
- :type pos: :class:`geom.Vec3`
- :param radius: The radius of the sphere
- :type radius: float
-
- :returns: A list of :class:`AtomHandles<AtomHandle>`
-
-.. class:: ChainHandle
-
- .. method:: FindResidue(res_num)
-
- Get residue by residue number. See also :meth:`GetResidueList`
-
- :param res_num: residue number
- :type res_num: mol.ResNum
-
- :returns: A valid :class:`ResidueHandle` if the chain contains
- a residue with matching residue number, an invalid
- :class:`ResidueHandle` otherwise.
-
- .. method:: GetResidueList()
-
- Get list of all residues of this chain. For peptide chains, the residues
- are usually ordered from N- to C-terminus.To access a single residue, use
- :meth:`FindResidue`.
-
- :returns: A list of :class:`ResidueHandles<ResidueHandle>`
-
- .. method:: FindAtom(res_num, atom_name)
-
- Get atom by residue number and atom name. See also :meth:`GetAtomList`
-
- :param res_num: residue number
- :type res_num: mol.ResNum
- :param atom_name: atom name, e.g. CA
- :type atom_name: string
-
- :returns: A valid :class:`AtomHandle` if an atom matching the
- parameters could be found, an invalid
- :class:`AtomHandle` otherwise
-
- .. method:: GetAtomList()
-
- Get list of all atoms of this chain. To access a single atom, use
- :meth:`FindAtom`
-
- :returns: A list of :class:`AtomHandles<AtomHandle>`
-
-.. class:: ResidueHandle
-
- .. method:: FindAtom(atom_name)
-
- Get atom by atom name. See also :meth:`GetAtomList`
-
- :param atom_name: atom name, e.g. CA
- :type atom_name: string
-
- :returns: A valid :class:`AtomHandle` if an atom with the given
- name could be found, an invalid :class:`AtomHandle`
- otherwise
-
- .. method:: GetAtomList()
-
- Get list of all atoms of this residue. To access a single atom, use
- :meth:`FindAtom`.
-
-.. class:: AtomHandle
-
-.. class:: EntityView
-
- Represents a subpart of an :class:`EntityHandle`.
-
-Functions
---------------------------------------------------------------------------------
-
-
-Boolean Operators
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. function:: Intersection(view_a, view_b)
-
- Calculates and returns the intersection of `view_a` and `view_b`. `view_a`
- and `view_b` must be views of the same entity.
-
- :param view_a: first view
- :type view_a: EntityView
- :param view_b: second view
- :type view_b: EntityView
-
-.. function:: Difference(view_a, view_b)
-
- Calculates and returns the difference between `view_a` and `view_b`. `view_a`
- and `view_b` must be views of the same entity.The returned view will
- contain atoms, residues, chains and bonds that are in `view_a` and not in
- `view_b`.
-
- :param view_a: first view
- :type view_a: EntityView
- :param view_b: second view
- :type view_b: EntityView
-
-.. function:: Union(view_a, view_b)
-
- Calculates and returns the union of `view_a` and `view_b`. `view_a`
- and `view_b` must be views of the same entity.The returned view will contain
- all atoms, residues, chains and bonds that are either in `view_a`, `view_b`
- or part of both views.
-
- :param view_a: first view
- :type view_a: EntityView
- :param view_b: second view
- :type view_b: EntityView
-
-
-Other Entity-Related Functions
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-.. function:: CreateViewFromAtomList(atom_list)
-
- Returns a view made up of the atoms in *atom_list*. All atoms are required to
- be atoms of the same entity. Duplicate atoms are only added to the view once.
-
- :param atom_list: the atoms
- :type atom_list: :class:`AtomHandleList` or :class:`AtomViewList`
- :raises: :class:`IntegrityError` if atoms of different entities are
- encountered
-
- :returns: :class:`EntityView`
\ No newline at end of file
diff --git a/doc/source/mol/base/mol.rst b/doc/source/mol/base/mol.rst
deleted file mode 100644
index a16b21f541edbec24a14ea8f96c9183adc9cf4f3..0000000000000000000000000000000000000000
--- a/doc/source/mol/base/mol.rst
+++ /dev/null
@@ -1,14 +0,0 @@
-:mod:`~ost.mol` -- Molecular structures and surfaces
-================================================================================
-
-.. module:: ost.mol
- :synopsis: Contains classes and functions to deal with molecular structures
- and surfaces
-
-The mol module implement data structure to work with molecular datasets. At its heart lie the :class:`EntityHandle` and :class:`EntityView` classes which represent molecular structures such as proteins, DNA, RNA and small molecules. There are also classes to deal with molecular surfaces.
-
-.. toctree::
-
- entity
- editors
- query
\ No newline at end of file
diff --git a/doc/source/mol/base/query.rst b/doc/source/mol/base/query.rst
deleted file mode 100644
index 20c4b711a2a0e9c190efce278af82df16ac84ee1..0000000000000000000000000000000000000000
--- a/doc/source/mol/base/query.rst
+++ /dev/null
@@ -1,124 +0,0 @@
-Queries
-================================================================================
-
-.. class:: Query
-
- Blabla
-
-It is often convenient to highlight or focus certain parts of the structure.
-OpenStructure includes a powerful query system that allows you to perform custom
-selections in a convenient way.
-
-Please refer to the tutorial on the query language for an introduction.
-
-The query language reference
---------------------------------------------------------------------------------
-
-The query consists of one or more predicates combined with boolean
-operators. A predicate takes the form *prop op value*. Operators are
-one of `` =, !=, >, >=, <=`` and ``<``. A predicate has the following form:
-*PROPERTY - OPERATOR - ARGUMENT*.
-
-The following properties may be used in predicates. The supported type of the
-value is given for each property.
-
- * ``rname`` residue name. type: string
- * ``rnum`` residue number. currently only numeric part is honored.
- type: int
- * ``rtype`` residue type as given by the DSSP code, i.e. H for helix, E
- for extended. type: string
- * ``aname`` atom name. type: string
- * ``ele`` element of atom. type: string
- * ``cname`` chain name. type: string
- * ``occ`` occupancy, between 0 and 1. type: float
- * ``abfac`` B (temperature) factor of atom. type: float
- * ``rbfac`` average B (temperature) factor of residue. type: float.
- Note that this does not work for views as expected. When running a
- second selection statement on a view, all atoms of the residue handle
- and not the view are considered in the calculation
- * ``ishetatm`` whether the atom is a hetorogenous atom. type: bool or int
- (0 for false, 1 for true)
- * ``peptide`` whether the residue is peptide linking. type: bool or int
- (0 for false, 1 for true)
- * ``x`` X coordinate of atom. type: float
- * ``y`` Y coordinate of atom. type: float
- * ``z`` Z coordinate of atom. type: float
- * ``rindex`` index of residue in chain. This index is the same for views
- and handles
- * For :ref:`generic properties in queries <genprop-in-queries>` see below.
-
-Distance-based selections within a given atom position are supported by
-the within statement. To select atoms within 5 Angstrom of the point
-``{1, 2, 3}``, one would write:
-
-``5 <> {1,2,3}``
-
-Negation of this expression is possible with the not operator, i.e.
-
-``not 5 <> {1,2,3}``
-will select atoms that are further than five Angstrom apart from ``{1, 2 , 3}``
-
-Abbreviations
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Two abbreviations exist for convenience:
-
-Instead of writing
-
-``aname=CA or aname=C or aname=O or aname=N``,
-
-one can write
-
-``aname=CA,N,C,O``.
-
-For integral value ranges, one can use the colon syntax: instead of
-
-``rnum>=10 and rnum<=20``
-
-one can write
-
-``rnum=10:20``
-
-.. _genprop-in-queries:
-
-Generic Properties in Queries
---------------------------------------------------------------------------------
-
-The query language can also be used for numeric generic properties (i.e.
-float and int), but the syntax is slightly different. To access any generic
-properties, it needs to be specified that they are generic and at which level
-they are defined. Therefore, all generic properties start with a ``g``, followed by an ``a``, ``r`` or ``c`` for atom, residue or chain level respectively.
-
-.. code-block:: python
-
- # set generic properties for atom, residue, chain
- atom_handle.SetFloatProp("testpropatom", 5.2)
- resid_handle.SetFloatProp("testpropres", 1.1)
- chain_handle.SetIntProp("testpropchain", 10)
-
- # query statements
- sel_a=e.Select("gatestpropatom<=10.0")
- sel_r=e.Select("grtestpropres=1.0")
- sel_c=e.Select("gctestpropchain>5")
-
-Since generic properties do not need to be defined for all parts of an entity
-(e.g. it could be specified for one single :class:`AtomHandle`), the query
-statement will throw an error unless you specify a default value in the query
-statement which can be done using a ':' character:
-
-.. code-block:: python
-
- # if one or more atoms have no generic properties
-
- sel=e.Select("gatestprop=5")
- # this will throw an error
-
- # you can specify a default value:
- sel=e.Select("gatestprop:1.0=5")
- # this will run through smoothly and use 1.0 as
- # the default value for all atoms that do not
- # have the generic property 'testprop'
-
-Using this method, you will be warned if a generic property is not set for all
-atoms, residues or chains unless you specify a default value. So, be careful
-when you do.
diff --git a/doc/source/newmodule.rst b/doc/source/newmodule.rst
deleted file mode 100644
index a45283055f5a4e60af1f468b5846857d7c3c28c1..0000000000000000000000000000000000000000
--- a/doc/source/newmodule.rst
+++ /dev/null
@@ -1,301 +0,0 @@
-Creating a New Module
-================================================================================
-
-OpenStructure can be extended by writing additional modules. A module will
-usually consist of a set of C++ classes and methods, most of which will also be
-exported to Python. It is also possible to write modules completely in Python.
-
-The build system of OpenStructure is quite simple. The main difference to other
-projects is the use of a so-called stage directory. The stage directory
-replicates the normal layout of a standard Linux directory structure, with an
-'include' directory for the headers, a 'lib' directory containing the shared
-library files, a `bin` directory for the executables and a 'share' directory
-for the platform-independent data like icons, images and examples.
-
-OpenStructure uses `CMake <http://www.cmake.org>`_ to build the project. The
-rules for the build-system are defined in `CMakeLists.txt` files. When running
-`CMake <http://cmake.org>`_, the files are compiled and copied into stage. The
-real installation, if necessary, happens at a later stage. This is referred to
-as staging of the files.
-
-If a new module is written following the guidelines in this page, it will be
-seamlessly included in the build system and will then be available form both
-the DNG python console and the OpenStructure command line as any other native
-module.
-
-As a first step, a new directory structure must be created to accommodate the
-new module.
-
-Directory Structure
---------------------------------------------------------------------------------
-
-For the purpose of this example, let's assume we are creating a new module
-called 'mod' (for 'modeling'). Let's create a directory named `mod` under the
-'modules' directory in the OpenStructure development tree, and populate it with
-the three subdirectories `src`, `pymod`, and `tests`. Then we add a
-`CMakeLists.txt` file in the 'mod' directory, consisting of three lines:
-
-.. code-block:: bash
-
- add_subdirectory(src)
- add_subdirectory(pymod)
- add_subdirectory(tests)
-
-The Module Code
---------------------------------------------------------------------------------
-
-In the `src` subdirectory we put the code that implements the functionality of
-the new module, plus a `config.hh` header file.
-
-Here is a skeleton of one of the files in the directory , `modeling_new_class.hh`:
-
-.. code-block:: cpp
-
- #ifndef OST_MOD_NEW_CLASS_H
- #define OST_MOD_NEW_CLASS_H
-
- #include <ost/mod/module_config.hh>
-
- // All other necessary includes go here
-
- namespace ost { namespace mod {
-
- class DLLEXPORT_OST_MOD NewClass {
- public:
- void NewMethod();
-
- // All declarations of NewClass go here
-
- };
-
- }} // namespaces
-
- #endif
-
-And here is the skeleton of the corresponding `modeling_new_class.cc` file:
-
-.. code-block:: cpp
-
- #include "modeling_new_class.hh"
-
- using namespace ost::mol;
- using namespace ost::mod;
-
- // All other necessary includes and namespace directives
- // go here
-
- void NewClass::NewMethod():
- {
- // Implementation
- }
-
- // Implementation code for NewClass goes here
-
-Obviously, the `src` directory can contain many files, each implementing classes
-and functions that will end up in the module. In order to build and stage
-the module shared library, a `CMakeLists.txt` file needs to be written for the
-`src` directory:
-
-.. code-block:: bash
-
- set(OST_MOD_SOURCES
- modeling_new_class.cc
- // All other source files
- )
-
- set(OST_MOD_HEADERS
- modeling_new_class.hh
- // All other header files
- )
-
- module(NAME mod SOURCES "${OST_MOD_SOURCES}"
- HEADERS ${OST_MOD_HEADERS}
- DEPENDS_ON mol mol_alg)
-
-
-The line containing the `DEPENDS_ON` directive lists all the modules on which
-the new module depends (in this case :mod:`mol` and :mod:`ost.mol.alg`). The
-`module` macro will take care of staging the headers, in this case into
-`ost/mod` and compiling, linking and staging of a library with the name
-`libost_mod.so` (`libost_gmod.dylib` on MacOS X).
-
-.. note::
-
- Due to a limitation in the built-int install command of CMake, for modules
- that have their headers in several directories, it is required to group the
- headers by directory, leading to a call of module like:
-
-.. code-block:: bash
-
- module(NAME mol SOURCES atom_handle.cc impl/atom_impl.cc
- HEADERS atom_impl.hh IN_DIR impl
- atom_handle.hh)
-
-The `module_config.hh` header is required for each module to setup the
-environment on Windows: Each public class, method and function needs to marked
-with `DLLEXPORT` or `DLLIMPORT` to teach the linker where to look for the
-symbol. The correct use of either `DLLIMPORT` and `DLLEXPORT` is depending on
-the context: While compiling a header file that is part of the same shared
-library, `DLLEXPORT` must be used. When compiling a header that is part of
-an external shared library, `DLLIMPORT` must be used. A typical module_config
-header looks like this:
-
-.. code-block:: cpp
-
- #ifndef OST_MOD_MODULE_CONFIG_HH
- #define OST_MOD_MODULE_CONFIG_HH
-
- #include <ost/base.hh>
-
- #if defined(OST_MODULE_OST_MOD)
- # define DLLEXPORT_OST_MOD DLLEXPORT
- #else
- # define DLLEXPORT_OST_MOD DLLIMPORT
- #endif
- #endif
-
-The Testing Framework
---------------------------------------------------------------------------------
-
-The `tests` directory contains code for unit tests. The code is compiled and
-executed when one invokes compilation using the 'make check' command. Tests are
-run by means of the `Boost Unitests Library
-<http://www.boost.org/doc/libs/1_37_0/libs/test/doc/html/index.html>`_, which is
-used throughout OpenStructure. Before coding the test routines, the required
-skeleton needs to be put in place.
-
-The main code is put into 'tests.cc', which will become the test executable:
-
-.. code-block:: cpp
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- #include "test_modeling.hh"
-
- test_suite*
- unit_unit_test_suite( int argc, char * argv[] ) {
- std::auto_ptr<test_suite> test(BOOST_TEST_SUITE( "Module Mod Test" ));
-
- test->add(CreateModelingTest());
-
- return test.release();
- }
-
-
-The most relevant line adds the test suite for the new module to the global test
-list. The test suite is created by the factory function CreateModelingTest(),
-which is declared in the `test_modeling.hh` header file.
-
-.. code-block:: cpp
-
- #ifndef OST_MOD_TEST_MODELING_H
- #define OST_MOD_TEST_MODELING_H
-
- #include <boost/test/unit_test.hpp>
- using boost::unit_test_framework::test_suite;
-
- test_suite* CreateModelingTest();
-
- #endif
-
-The definition of the factory function is found in the actual test code,
-which we put in `test_modeling.cc`. Here is a skeleton version of that file:
-
-.. code-block:: cpp
-
- #include "test_modeling.hh"
-
- // additional include statements will go here
-
- namespace test_modeling {
-
- void test()
- {
- // test code will go here
- }
-
- }
-
- test_suite* CreateModelingTest()
- {
- using namespace test_modeling;
- test_suite* ts=BOOST_TEST_SUITE("Modeling Test");
- ts->add(BOOST_TEST_CASE(&test));
-
- return ts;
- }
-
-In this file, all the normal Boost Test Library macros and functions can be used. (For example `BOOST_CHECK`, `BOOST_FAIL`, etc.)
-
-Here is finally the build script skeleton that needs to be put into
-`mod/tests/`:
-
-.. code-block:: bash
-
- set(OST_MOD_UNIT_TESTS
- tests.cc
- test_modeling.cc
- )
-
- ost_unittest(mod "${OST_MOD_UNIT_TESTS}")
- target_link_libraries(ost_mol ost_mol_alg ost_mod)
-
-In the last line the call to the 'target\_link\_libraries' function contains the
-names of the modules on which the 'mod' unit test code depends (in this case,
-the :mod:`mol` and :mod:`ost.mol.alg` modules), in addition to the `mod` module
-itself.
-
-The Python Wrapper
---------------------------------------------------------------------------------
-
-Finally, the module API is exported to Python using the `Boost Python
-Library <http://www.boost.org/doc/libs/1_37_0/libs/python/doc/index.html>`_.
-In `mod/pymod`, the wrapper code for the classes in the new module is put into a
-file named `wrap\_mod.cc`:
-
-.. code-block:: cpp
-
- #include <boost/python.hpp>
- using namespace boost::python;
-
- #include <ost/mod/modeling_new_class.hh>
-
- using namespace ost::mol;
- using namespace ost::mod;
-
- // All other necessary includes and namespace directives
- // go here
-
- BOOST_PYTHON_MODULE(_mod)
- {
- class_<NewClass>("NewClass", init<>() )
- .def("NewMethod", &NewClass::NewMethod)
- ;
-
- // All other Boost Python code goes here
- }
-
-The `mod/pymod` directory must obviously contain a `CMakeLists.txt` file:
-
-.. code-block:: bash
-
- set(OST_MOD_PYMOD_SOURCES
- wrap_mod.cc
- )
-
- pymod(NAME mod OUTPUT_DIR ost/mod
- CPP ${OST_MOD_PYMOD_SOURCES} PY __init__.py)
-
-The directory should also contain an `__init.py__` file with the
-following content:
-
-.. code-block:: python
-
- from _mod import *
-
-In case one wants to implement Python-only functionality for the new module, any
-number of function definitions can be added to the `__init.py__` file.
-
-That's it!. The next time the OpenStructure project is compiled, the new module
-will be built and made available at both the C++ and the Python level.
diff --git a/doc/source/seq/base/seq.rst b/doc/source/seq/base/seq.rst
deleted file mode 100644
index 7deafe22e797a6d0c4f1ab22cc041f56e5889cbc..0000000000000000000000000000000000000000
--- a/doc/source/seq/base/seq.rst
+++ /dev/null
@@ -1,350 +0,0 @@
-:mod:`~ost.seq` -- Sequences and Alignments
-================================================================================
-
-.. module:: ost.seq
- :synopsis: Contains classes and functions to deal with sequences and
- alignments
-
-The :mod:`seq` module helps you working with sequence data of various kinds. It
-has classes for :class:`single sequences <SequenceHandle>`, :class:`lists of
-sequences <SequenceList>` and :class:`alignments <AlignmentHandle>` of two or
-more sequences.
-
-
-.. _attaching-views:
-
-Attaching Structures to Sequences
---------------------------------------------------------------------------------
-
-
-Being a structural biology framework, it is not surprising that the sequence
-classes have been designed to work together with structural data. Each sequence
-can have an attached :class:`~mol.EntityView` allowing for fast mapping between
-residues in the entity view and position in the sequence.
-
-.. _sequence-offset:
-
-Sequence Offset
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-When using sequences and structures together, often the start of the structure
-and the beginning of the sequence do not fall together. In the following case,
-the alignment of sequences B and C only covers a subpart of structure A::
-
- A acefghiklmnpqrstuvwy
- B ghiklm
- C 123-45
-
-We would now like to know which residue in protein A is aligned to which residue
-in sequence C. This is achieved by setting the sequence offset of sequence C to
-4. In essence, the sequence offset influences all the mapping operations from
-position in the sequence to residue index and vice versa. By default, the
-sequence offset is 0.
-
-Loading and Saving Sequences and Alignments
---------------------------------------------------------------------------------
-
-The :mod:`io` module supports input and output of common sequence formats.
-Single sequences can be loaded from disk with :func:`io.LoadSequence`,
-alignments are loaded with :func:`io.LoadAlignment` and lists of sequences are loaded with :func:`io.LoadSequenceList`. In addition to the file based input
-methods, sequences can also be loaded from a string:
-
-.. code-block:: python
-
- seq_string='''>sequence
- abcdefghiklmnop'''
- s=io.LoadSequenceFromString(seq_string, 'fasta')
- print s.name, s # will print "sequence abcdefghiklmnop"
-
-Note that, in that case specifying the format is mandatory.
-
-The SequenceHandle
---------------------------------------------------------------------------------
-
-.. function:: CreateSequence(name, sequence)
-
- Create a new :class:`SequenceHandle` with the given name and sequence.
-
- :param name: name of the sequence
- :type name: str
- :param sequence: String of characters representing the sequence. Only
- alphanumerical characters and '-' are allowed.
- :type sequence: str
- :raises InvalidSequence: When the sequence string contains forbidden
- characters, that is anything that is not alphanumeric or a hyphen.
-
-.. class:: SequenceHandle
-
- Represents a sequence. New instances are created with :func:`CreateSequence`.
-
- .. method:: GetPos(residue_index)
-
- Get position of residue with index in sequence. This is best illustrated in
- the following example:
-
- .. code-block:: python
-
- s=seq.CreateSequence("A", "abc---def")
- print s.GetPos(1) # prints 1
- print s.GetPos(3) # prints 6
-
- The reverse mapping, that is from position in the sequence to residue index
- can be achieved with :meth:`GetResidueIndex`.
-
- .. method:: GetResidueIndex(pos)
-
- Get residue index of character at given position. This method is the
- inverse of :meth:`GetPos`. If the sequence contains a gap at that position,
- an :exc:`Error` is raised.
-
- .. code-block:: python
-
- s=seq.CreateSequence("A", "abc--def")
- print s.GetResidueIndex(1) # prints 1
- print s.GetResidueIndex(6) # prints 4
- # the following line raises an exception of type
- # Error with the message "requested position contains
- # a gap"
- print s.GetResidueIndex(3)
-
- .. method:: GetLastNonGap()
-
- Get position of last non-gap character in sequence. In case of an empty
- sequence, or, a sequence only consisting of hyphens, -1 is returned
-
- .. method:: GetFirstNonGap()
-
- Get position of first non-gap character in sequence. In case of an empty
- sequence, or, a sequence only consisting of hyphens, -1 is returned.
-
- .. method:: AttachView(view)
- AttachView(view, [chain_name])
-
- Attach an :class:`~mol.EntityView` to sequence. The first signature requires
- that the view contains one chain. If not, an :exc:`IntegrityError` is
- raised. The second signature will select the chain with the given name. If
- no such chain exists, an :exc:`IntegrityError` is raised.
-
- .. method:: HasAttachedView()
-
- Returns True when the sequence has a view attached, False if not.
-
- .. method:: GetAttachedView()
-
- Returns the attached :class:`~mol.EntityView`, or an invalid
- :class:`~mol.EntityView` if no view has been attached. Also available as
- the property :attr:`attached_view`.
-
- .. method:: GetName()
-
- Returns the name of the sequence. Also available as the property
- :attr:`name`
-
- .. method:: SetSequenceOffset()
-
- Set the :ref:`sequence offset <sequence-offset>`. By default, the offset is
- 0. Also available as the property :attr:`sequence_offset`.
-
- .. method:: GetSequenceOffset()
-
- Returns the :ref:`sequence offset <sequence-offset>`. Also available as
- :attr:`sequence_offset`.
-
-
- .. method:: GetGaplessString()
-
- Returns a string version of this sequence with all hyphens removed. Also
- available as the property :attr:`gapless_string`.
-
-
- .. method:: SetName()
-
- Set name of the sequence. Also available as the property :attr:`name`.
-
- .. attribute:: gapless_string
-
- Shorthand for :meth:`GetGaplessString()`
-
- .. attribute:: name
-
- Shorthand for :meth:`GetName`/:meth:`SetName`
-
- .. attribute:: attached_view
-
- Shorthand for :meth:`GetAttachedView`.
-
- .. attribute:: sequence_offset
-
- Shorthand for :meth:`GetSequenceOffset`/:meth:`SetSequenceOffset`
-
- .. method:: __len__()
-
- Returns the length of the sequence (including insertions and deletions)
-
- .. method:: __str__()
-
- Returns the sequence as a string.
-
-
-The SequenceList
---------------------------------------------------------------------------------
-
-.. class:: SequenceList
-
- Represents a list of sequences. The class provides a row-based interface. New
- instances are created with :func:`CreateSequenceList`.
-
-
-The AlignmentHandle
---------------------------------------------------------------------------------
-
-The :class:`AlignmentHandle` represents a list of aligned sequences. In
-constrast to :class:`SequenceList`, an alignment requires all sequences to be of
-the same length. New instances of alignments are created with
-:func:`CreateAlignment` and :func:`AlignmentFromSequenceList`.
-
-Typically sequence alignments are used column-based, i.e by looking at an
-aligned columns in the sequence alignment. To get a row-based (sequence) view
-on the sequence list, use :meth:`GetSequenceList()`.
-
-All functions that operate on an alignment will again produce a valid alignment.
-This mean that it is not possible to change the length of one sequence, without
-adjusting the other sequences, too.
-
-The following example shows how to iterate over the columns and sequences of
-an alignment:
-
-.. code-block:: python
-
- aln=io.LoadAlignment('aln.fasta')
- # iterate over the columns
- for col in aln:
- print col
-
- # iterate over the sequences
- for s in aln.sequences:
- print s
-
-.. function:: CreateAlignment()
-
- Creates and returns a new :class:`AlignmentHandle` with no sequences.
-
-.. function:: AlignmentFromSequenceList(sequences)
-
- Create a new alignment from the given list of sequences
-
- :param sequences: the list of sequences
- :type sequences: :class:`ConstSequenceList`
-
- :raises: :exc:`InvalidAlignment` if the sequences do not have the same length.
-
-.. class:: AlignmentHandle
-
- .. note::
-
- Several of these methods just forward calls to the sequence. For more
- detailed information, have a look at the :class:`SequenceHandle`
- documentation.
-
- .. method:: GetSequence(index)
-
- Returns the sequence at the given index, raising an IndexError when trying
- to access an inexistent sequence.
-
- .. method:: GetSequenceList()
-
- Returns a list of all sequence of the alignment.
-
- .. method:: GetLength()
-
- Returns the length of the alignment.
-
- .. method:: GetCount()
-
- Returns the number of sequences in the alignment.
-
-
- .. method:: ToString(width=80)
-
- Returns a formatted string version of the alignment. The sequences are
- split into smaller parts to fit into the number columns specified.
-
- .. code-block:: python
-
- aln=seq.CreateAlignment()
- aln.AddSequence(seq.CreateSequence("A", "abcdefghik"))
- aln.AddSequence(seq.CreateSequence("B", "1234567890"))
- # The following command will print the output given below
- print aln.ToString(7)
- # A abcde
- # B 12345
- #
- # A fghik
- # B 67890
-
- .. method:: FindSequence(name)
-
- Find sequence with given name. If the alignment contains several sequences
- with the same name, the first sequence is returned.
-
- .. method:: SetSequenceName(seq_index, name)
-
- Set the name of the sequence at index `seq_index` to name
-
- .. method:: SetSequenceOffset(seq_index, offset)
-
- Set the sequence offset of sequence at index `seq_index`
-
- .. method:: Copy()
-
- Create a deep copy of the alignment
-
- .. method:: GetPos(seq_index, res_index)
-
- Get position of residue with index equal to `res_index` in sequence at index
- `seq_index`.
-
- .. method:: GetResidueIndex(seq_index, pos)
-
- Get residue index of residue at position `pos` in sequence at index
- `seq_index`.
-
- .. method:: AttachView(seq_index, view)
- AttachView(seq_index, view, chain_name)
-
- Attach the given view to the sequence at index `seq_index`.
-
- .. method:: Cut(start, end)
-
- Removes the columns in the half-closed interval `start`, `end` from the
- alignment.
-
- .. code-block:: python
-
- aln=seq.CreateAlignment()
- aln.AddSequence(seq.CreateSequence("A", "abcd---hik"))
- aln.AddSequence(seq.CreateSequence("B", "1234567890"))
- aln.Cut(4, 7)
-
- print aln.ToString(80)
- # will print
- # A abcdhik
- # B 1234890
-
- .. method:: Replace(new_region, start, end)
-
- Replace the columns in the half-closed interval `start`, `end` with the
- columns in `new_region`.
-
- :param new_region: The region to be inserted
- :type new_region: :class:`AlignedRegion` or :class:`AlignmentHandle`
-
-
- .. method:: ShiftRegion(start, end, amount, master=-1)
-
- Shift columns in the half-closed interval `start`, `end`. If amount is a
- positive number, the columns are shifted to the right, if negative, the
- columns are shifted to the left.
-
- If master is set to -1, all sequences in the region are affected, otherwise
- only the sequence at index equal to master is shifted.