Refs #10900. Updated class- and method documentation in MantidGeometry

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScatterer.h

@@ -15,7 +15,12 @@ namespace Geometry {
 
 typedef std::complex<double> StructureFactor;
 
-/** BraggScatterer
+class BraggScatterer;
+
+typedef boost::shared_ptr<BraggScatterer> BraggScatterer_sptr;
+
+/**
+    @class BraggScatterer
 
     BraggScatterer is a general interface for representing scatterers
     in the unit cell of a periodic structure. Since there are many possibilities
@@ -60,11 +65,6 @@ typedef std::complex<double> StructureFactor;
     File change history is stored at: <https://github.com/mantidproject/mantid>
     Code Documentation is available at: <http://doxygen.mantidproject.org>
   */
-
-class BraggScatterer;
-
-typedef boost::shared_ptr<BraggScatterer> BraggScatterer_sptr;
-
 class MANTID_GEOMETRY_DLL BraggScatterer : public Kernel::PropertyManager {
 public:
   BraggScatterer();

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererFactory.h

@@ -9,7 +9,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** BraggScattererFactory :
+/**
+    @class BraggScattererFactory
 
     This class implements a factory for concrete BraggScatterer classes.
     When a new scatterer is derived from BraggScatterer, it should be registered
@@ -21,20 +22,20 @@ namespace Geometry {
     At runtime, instances of this class can be created like this:
 
         BraggScatterer_sptr scatterer =
-   BraggScattererFactory::Instance().createScatterer("NewScattererClass");
+        BraggScattererFactory::Instance().createScatterer("NewScattererClass");
 
     The returned object is initialized, which is required for using the
     Kernel::Property-based system of setting parameters for the scatterer.
     To make creation of scatterers more convenient, it's possible to provide
     a string with "name=value" pairs, separated by semi-colons, which assigns
     property values. This is similar to the way
-   FunctionFactory::createInitialized works:
+    FunctionFactory::createInitialized works:
 
         BraggScatterer_sptr s = BraggScattererFactory::Instance()
                                                .createScatterer(
                                                     "NewScatterer",
-                                                    "SpaceGroup=F m -3 m;
-   Position=[0.1,0.2,0.3]");
+                                                    "SpaceGroup=F m -3 m;"
+                                                    "Position=[0.1,0.2,0.3]");
 
     If you choose to use the raw create/createUnwrapped methods, you have to
     make sure to call BraggScatterer::initialize() on the created instance.

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererInCrystalStructure.h

@@ -9,7 +9,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** BraggScattererInCrystalStructure
+/**
+    @class BraggScattererInCrystalStructure
 
     This class provides an extension of BraggScatterer, suitable
     for scatterers that are part of a crystal structure. Information about

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CenteringGroup.h

@@ -10,7 +10,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** CenteringGroup
+/**
+    @class CenteringGroup
 
     This class is mostly a convenience class. It takes a bravais lattice symbol
     (P, I, A, B, C, F, R) and forms a group that contains all translations

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CompositeBraggScatterer.h

@@ -7,7 +7,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** CompositeBraggScatterer
+/**
+    @class CompositeBraggScatterer
 
     CompositeBraggScatterer accumulates scatterers, for easier calculation
     of structure factors. Scatterers can be added through the method
@@ -15,26 +16,23 @@ namespace Geometry {
     it is cloned instead, so there is a new instance. The original instance
     is not modified at all.
 
-    For structure factor calculations, all contributions from contained
-   scatterers
-    are summed. Contained scatterers may be CompositeBraggScatterers themselves,
-    so it's possible to build up elaborate structures.
+    For structure factor calculations, all contributions from
+    contained scatterers are summed. Contained scatterers may be
+    CompositeBraggScatterers themselves, so it's possible to build up elaborate
+    structures.
 
     There are two ways of creating instances of CompositeBraggScatterer. The
-   first
-    possibility is to use BraggScattererFactory, just like for other
-   implementations
-    of BraggScatterer. Additionally there is a static method
-   CompositeBraggScatterer::create,
-    which creates a composite scatterer of the supplied vector of scatterers.
+    first possibility is to use BraggScattererFactory, just like for other
+    implementations of BraggScatterer. Additionally there is a static method
+    CompositeBraggScatterer::create, which creates a composite scatterer of
+    the supplied vector of scatterers.
 
     CompositeBraggScatterer does not declare any methods by itself, instead it
-   exposes
-    some properties of the contained scatterers (those which were marked using
-    exposePropertyToComposite). When these properties are set, their values
-    are propagated to all members of the composite. The default behavior when
-    new properties are declared in subclasses of BraggScatterer is not to expose
-    them in this way.
+    exposes some properties of the contained scatterers (those which were marked
+    using exposePropertyToComposite). When these properties are set,
+    their values are propagated to all members of the composite. The default
+    behavior when new properties are declared in subclasses of BraggScatterer is
+    not to expose them in this way.
 
       @author Michael Wedel, Paul Scherrer Institut - SINQ
       @date 21/10/2014

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CrystalStructure.h

@@ -14,7 +14,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** CrystalStructure :
+/**
+    @class CrystalStructure
 
     Three components are required to describe a crystal structure:
 
@@ -47,7 +48,8 @@ namespace Geometry {
     one of the ReflectionCondition-classes directly:
 
         ReflectionCondition_sptr fCentering =
-   boost::make_shared<ReflectionConditionAllFaceCentred>();
+            boost::make_shared<ReflectionConditionAllFaceCentred>();
+
         structure.setCentering(fCentering);
 
     Now, only reflections that fulfill the centering condition are
@@ -58,7 +60,8 @@ namespace Geometry {
     is to directly assign a point group:
 
         PointGroup_sptr pointGroup =
-   PointGroupFactory::Instance().createPointGroup("m-3m");
+            PointGroupFactory::Instance().createPointGroup("m-3m");
+
         structure.setPointGroup(pointGroup);
 
         std::vector<V3D> uniqueHKLs = structure.getUniqueHKLs(0.5, 10.0);
@@ -81,25 +84,21 @@ namespace Geometry {
     one Si-atom at the position (1/8, 1/8, 1/8) (for origin choice 2, with the
     inversion at the origin). Looking up this space group in the International
     Tables for Crystallography A reveals that placing a scatterer at this
-   position
-    introduces a new reflection condition for general reflections hkl:
+    position introduces a new reflection condition for general reflections hkl:
 
            h = 2n + 1 (reflections with odd h are allowed)
         or h + k + l = 4n
 
     This means that for example the reflection family {2 2 2} is not allowed,
     even though the F-centering would allow it. In other words, guessing
-   existing
-    reflections of silicon only using lattice information does not lead to the
-    correct result. Besides that, there are also glide planes in that space
-   group,
-    which come with additional reflection conditions as well.
+    existing reflections of silicon only using lattice information does not lead
+    to the correct result. Besides that, there are also glide planes in that
+    space group, which come with additional reflection conditions as well.
 
     One way to obtain the correct result for this case is to calculate
     structure factors for each HKL and check whether |F|^2 is non-zero. Of
-   course,
-    to perform this calculation, all three items mentioned in the list at
-    the beginning must be present. CrystalStructure offers an additional
+    course, to perform this calculation, all three items mentioned in the list
+    at the beginning must be present. CrystalStructure offers an additional
     constructor for this purpose:
 
         CrystalStructure silicon(unitcell, spaceGroup, scatterers);
@@ -109,7 +108,7 @@ namespace Geometry {
     Now, a different method for checking allowed reflections is available:
 
         std::vector<V3D> uniqueHKLs = silicon.getUniqueHKLs(0.5, 10.0,
-   CrystalStructure::UseStructureFactors);
+                                         CrystalStructure::UseStructureFactors);
 
     By supplying the extra argument, |F|^2 is calculated for each reflection
     and if it's greater than 1e-9, it's considered to be allowed.

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CyclicGroup.h

@@ -10,12 +10,13 @@
 namespace Mantid {
 namespace Geometry {
 
-/** CyclicGroup :
+/**
+    @class CyclicGroup
 
     A cyclic group G has the property that it can be represented by
     powers of one symmetry operation S of order n:
 
-      G = { S^1, S^2, ..., S^n = S^0 = I }
+        G = { S^1, S^2, ..., S^n = S^0 = I }
 
     The operation S^m is defined as carrying out the multiplication
     S * S * ... * S. To illustrate this, a four-fold rotation around
@@ -23,18 +24,18 @@ namespace Geometry {
     transformation by this symmetry element is "-y,x,z". This is also the
     first member of the resulting group:
 
-      S^1 = S = -y,x,z
+        S^1 = S = -y,x,z
 
     Then, multiplying this by itself:
 
-      S^2 = S * S = -x,-y,z
-      S^3 = S * S * S = y,-x,z
-      S^4 = S * S * S * S = x,y,z = I
+        S^2 = S * S = -x,-y,z
+        S^3 = S * S * S = y,-x,z
+        S^4 = S * S * S * S = x,y,z = I
 
     Thus, the cyclic group G resulting from the operation "-y,x,z" contains
     the following members:
 
-      G = { S^1, S^2, S^3, I } = { -y,x,z; -x,-y,z; y,-x,z; x,y,z }
+        G = { S^1, S^2, S^3, I } = { -y,x,z; -x,-y,z; y,-x,z; x,y,z }
 
     This example shows in fact how the point group "4" can be generated as
     a cyclic group by the generator S = -y,x,z. Details about this
@@ -43,7 +44,7 @@ namespace Geometry {
     In code, the example is very concise:
 
         Group_const_sptr pointGroup4 =
-   GroupFactory::create<CyclicGroup>("-y,x,z");
+            GroupFactory::create<CyclicGroup>("-y,x,z");
 
     This is much more convenient than having to construct a Group,
     where all four symmetry operations would have to be supplied.

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/Group.h

@@ -13,7 +13,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** Group :
+/**
+    @class Group
 
     The class Group represents a set of symmetry operations (or
     symmetry group). It can be constructed by providing a vector
@@ -42,49 +43,42 @@ namespace Geometry {
     components of V3D are mapped onto the interval [0, 1).
 
     Two groups A and B can be combined by a multiplication operation, provided
-   by
-    the corresponding overloaded operator:
+    by the corresponding overloaded operator:
 
-      Group A, B;
-      Group C = A * B
+        Group A, B;
+        Group C = A * B
 
     In this operation each element of A is multiplied with each element of B
     and from the resulting list a new group is constructed. For better
-   illustration,
-    an example is provided. Group A has two symmetry operations: identity
-   ("x,y,z")
-    and inversion ("-x,-y,-z"). Group B also consists of two operations:
-    identity ("x,y,z") and a rotation around the y-axis ("-x,y,-z"). In terms
-    of symmetry elements, the groups are defined like this:
+    illustration, an example is provided. Group A has two symmetry operations:
+    identity ("x,y,z") and inversion ("-x,-y,-z"). Group B also consists of
+    two operations: identity ("x,y,z") and a rotation around the y-axis
+    ("-x,y,-z"). In terms of symmetry elements, the groups are defined like so:
 
         A := { 1, -1 }; B := { 1, 2 [010] }
 
     The following table shows all multiplications that are carried out and their
-    results (for multiplication of symmetry operations see SymmetryOperation):
-                             A
-                 |    x,y,z    -x,-y,-z
-         --------+------------------------
-           x,y,z |    x,y,z    -x,-y,-z
-       B         |
-         -x,y,-z |  -x,y,-z      x,-y,z
+    results (for multiplication of symmetry operations see SymmetryOperation)
+
+                   |    x,y,z   |  -x,-y,-z
+          -------- | ---------- | -----------
+            x,y,z  |    x,y,z   |  -x,-y,-z
+          -x,y,-z  |  -x,y,-z   |    x,-y,z
 
     The resulting group contains the three elements of A and B (1, -1, 2 [010]),
     but also one new element that is the result of multiplying "x,y,z" and
-   "-x,y,-z",
-    which is "x,-y,z" - the operation resulting from a mirror plane
-   perpendicular
-    to the y-axis. In fact, this example demonstrated how the combination of
-    two crystallographic point groups (see PointGroup documentation and wiki)
-    "-1" and "2" results in a new point group "2/m".
+    "-x,y,-z", which is "x,-y,z" - the operation resulting from a mirror plane
+    perpendicular to the y-axis. In fact, this example demonstrated how the
+    combination of two crystallographic point groups (see PointGroup
+    documentation and wiki) "-1" and "2" results in a new point group "2/m".
 
     Most of the time it's not required to use Group directly, there are several
     sub-classes that implement different behavior (CenteringGroup, CyclicGroup,
     ProductOfCyclicGroups) and are easier to handle. For construction there is a
-   simple
-    "factory function", that works for all Group-based classes which provide a
-    string-based constructor:
+    simple "factory function", that works for all Group-based classes which
+    provide a string-based constructor:
 
-      Group_const_sptr group = GroupFactory::create<CyclicGroup>("-x,-y,-z");
+        Group_const_sptr group = GroupFactory::create<CyclicGroup>("-x,-y,-z");
 
     However, the most useful sub-class is SpaceGroup, which comes with its
     own factory. For detailed information about the respective sub-classes,

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/IsotropicAtomBraggScatterer.h

@@ -8,14 +8,22 @@
 namespace Mantid {
 namespace Geometry {
 
-/** IsotropicAtomBraggScatterer
+class IsotropicAtomBraggScatterer;
+
+typedef boost::shared_ptr<IsotropicAtomBraggScatterer>
+    IsotropicAtomBraggScatterer_sptr;
+
+/** @class IsotropicAtomBraggScatterer
 
     IsotropicAtomBraggScatterer calculates the structure factor for
     a given HKL using the following equation, which gives the
     structure factor for the j-th atom in the unit cell:
 
-        F(hkl)_j = b_j * o_j * DWF_j(hkl) * exp[i * 2pi * (h*x_j + k*y_j +
-   l*z_j)]
+    \f[
+        F(hkl)_j = b_j \cdot o_j \cdot DWF_j(hkl) \cdot
+            \exp\left[2\pi i \cdot
+                \left(h\cdot x_j + k\cdot y_j + l\cdot z_j\right)\right]
+    \f]
 
     Since there are many terms in that equation, further explanation
     is required. The j-th atom in a unit cell occupies a certain position,
@@ -24,53 +32,54 @@ namespace Geometry {
     so called "phase". This term is easier seen when the complex part is written
     using trigonometric functions:
 
-        phi = 2pi * (h*x_j + k*y_j + l*z_j)
-        exp[i * phi] = cos(phi) + i * sin(phi)
+    \f{eqnarray*}{
+        \phi &=& 2\pi\left(h\cdot x_j + k\cdot y_j + l\cdot z_j\right) \\
+        \exp i\phi &=& \cos\phi + i\sin\phi
+    \f}
 
     The magnitude of the complex number is determined first of all by the
-    scattering length, b_j (which is element specific and tabulated, in
+    scattering length, \f$b_j\f$ (which is element specific and tabulated, in
     Mantid this is in PhysicalConstants::NeutronAtom). It is multiplied
-    by the occupancy o_j, which is a number on the interval [0, 1], where 0
+    by the occupancy\f$o_j\f$, which is a number on the interval [0, 1], where 0
     is a bit meaningless, since it means "no atoms on this position" and
     1 represents a fully occupied position in the crystal lattice. This number
     can be used to model statistically distributed defects.
 
-    DWF_j denotes the Debye-Waller-factor, which models the diminishing
+    \f$DWF_j\f$ denotes the Debye-Waller-factor, which models the diminishing
     scattering power of atoms that are displaced from their position
     (either due to temperature or other effects). It is defined like this:
 
-        DWF_j(hkl) = exp[-2.0 * pi^2 * U * 1/d(hkl)^2]
+    \f[
+        DWF_j(hkl) = \exp\left[-2\pi^2\cdot U \cdot 1/d_{hkl}^2\right]
+    \f]
 
-    Here, U is given in Angstrom^2 (for a discussion of terms regarding
-    atomic displacement parameters, please see [1]), it is often of the
-    order 0.05. d(hkl) is alculated using the unit cell. The model used
-    in this class is isotropic (hence the class name), which may be insufficient
-    depending on the crystal structure, but as a first approximation it is
-    often enough.
+    Here, \f$U\f$ is given in \f$\mathrm{\AA{}^2}\f$ (for a discussion of
+    terms regarding atomic displacement parameters, please see [1]),
+    it is often of the order 0.05. \f$d_{hkl}\f$ is alculated using
+    the unit cell. The model used in this class is isotropic
+    (hence the class name), which may be insufficient depending on the crystal
+    structure, but as a first approximation it is often enough.
 
     This class is designed to handle atoms in a unit cell. When a position is
-   set,
-    the internally stored space group is used to generate all positions that are
-    symmetrically equivalent. In the structure factor calculation method
-    all contributions are summed.
+    set, the internally stored space group is used to generate all positions
+    that are symmetrically equivalent. In the structure factor calculation
+    method all contributions are summed.
 
     Easiest is demonstration by example. Copper crystallizes in the space group
-    Fm-3m, Cu atoms occupy the position (0,0,0) and, because of the F-centering,
-    also 3 additional positions.
+    \f$Fm\bar{3}m\f$, Cu atoms occupy the position (0,0,0) and, because
+    of the F-centering, also 3 additional positions.
 
         BraggScatterer_sptr cu =
-   BraggScattererFactory::Instance().createScatterer(
-                                                            "IsotropicAtomBraggScatterer",
-                                                            "Element=Cu;
-   SpaceGroup=F m -3 m")
-        cu->setProperty("UnitCell", unitCellToStr(cellCu));
+            BraggScattererFactory::Instance().createScatterer(
+                "IsotropicAtomBraggScatterer",
+                "Element=Cu; SpaceGroup=F m -3 m")
 
+        cu->setProperty("UnitCell", unitCellToStr(cellCu));
         StructureFactor F = cu->calculateStructureFactor(V3D(1, 1, 1));
 
     The structure factor F contains contributions from all 4 copper atoms in the
-   cell.
-    This is convenient especially for general positions. The general position
-    of Fm-3m for example has 192 equivalents.
+    cell. This is convenient especially for general positions.
+    The general position of \f$Fm\bar{3}m\f$ for example has 192 equivalents.
 
     [1] http://ww1.iucr.org/comm/cnom/adp/finrep/finrep.html
 
@@ -97,11 +106,6 @@ namespace Geometry {
     File change history is stored at: <https://github.com/mantidproject/mantid>
     Code Documentation is available at: <http://doxygen.mantidproject.org>
   */
-class IsotropicAtomBraggScatterer;
-
-typedef boost::shared_ptr<IsotropicAtomBraggScatterer>
-    IsotropicAtomBraggScatterer_sptr;
-
 class MANTID_GEOMETRY_DLL IsotropicAtomBraggScatterer
     : public BraggScattererInCrystalStructure {
 public:

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/PointGroupFactory.h

@@ -10,13 +10,14 @@
 
 namespace Mantid {
 namespace Geometry {
-/** PointGroupFactory
+/**
+  @class PointGroupFactory
 
   A factory for point groups. Point group objects can be constructed by
   supplying the Hermann-Mauguin-symbol like this:
 
       PointGroup_sptr cubic =
-  PointGroupFactory::Instance().createPointgroup("m-3m");
+          PointGroupFactory::Instance().createPointgroup("m-3m");
 
   Furthermore it's possible to query available point groups, either all
   available

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ProductOfCyclicGroups.h

@@ -7,7 +7,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** ProductOfCyclicGroups :
+/**
+    @class ProductOfCyclicGroups
 
     ProductOfCyclicGroups expands a bit on the explanations given in
     CyclicGroup. As shown for example in [1], some point groups
@@ -20,14 +21,14 @@ namespace Geometry {
     a cyclic group C_i. The resulting n groups ("factor groups") are
     multiplied to form a product group G:
 
-      G = C_1 * C_2 * ... * C_n
+        G = C_1 * C_2 * ... * C_n
 
     Where C_i is generated by the symmetry operation S_i. The notation
     in code to generate even large groups from a few generators
     becomes very short using this class:
 
-      Group_const_sptr pointGroup422 =
-   GroupFactory::create<ProductOfCyclicGroups>("-y,x,z; x,-y,-z");
+        Group_const_sptr pointGroup422 =
+            GroupFactory::create<ProductOfCyclicGroups>("-y,x,z; x,-y,-z");
 
     This is for example used in SpaceGroupFactory to create space groups
     from a small set of generators supplied in the International Tables

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroup.h

@@ -11,7 +11,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** SpaceGroup :
+/**
+    @class SpaceGroup
 
     A class for representing space groups, inheriting from Group.
 
@@ -24,14 +25,13 @@ namespace Geometry {
     SpaceGroup may for example be used to generate all equivalent positions
     within the unit cell:
 
-      SpaceGroup_const_sptr someGroup;
+        SpaceGroup_const_sptr group;
 
-      V3D position(0.13, 0.54, 0.38);
-      std::vector<V3D> equivalents =
-   someGroup->getEquivalentPositions(position);
+        V3D position(0.13, 0.54, 0.38);
+        std::vector<V3D> equivalents = group->getEquivalentPositions(position);
 
-    The class should not be instantiated directly, see SpaceGroupFactory
-   instead.
+    The class should not be instantiated directly, see SpaceGroupFactoryImpl
+    instead.
 
       @author Michael Wedel, Paul Scherrer Institut - SINQ
       @date 03/10/2014

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroupFactory.h

@@ -14,7 +14,8 @@ namespace Geometry {
 bool MANTID_GEOMETRY_DLL
     isValidGeneratorString(const std::string &generatorString);
 
-/** AbstractSpaceGroupGenerator
+/**
+ * @class AbstractSpaceGroupGenerator
  *
  * AbstractSpaceGroupGenerator is used by SpaceGroupFactory to delay
  * (possibly costly) construction of space group prototype objects until
@@ -86,7 +87,8 @@ protected:
   Group_const_sptr generateGroup() const;
 };
 
-/** SpaceGroupFactory
+/**
+  @class SpaceGroupFactory
 
   This factory is used to create space group objects. Each space group
   should be created only once, which is why the factory works with

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperation.h

@@ -10,55 +10,49 @@
 namespace Mantid {
 namespace Geometry {
 
-/** SymmetryOperation :
+/**
+    @class SymmetryOperation
 
     Crystallographic symmetry operations are composed of a rotational component,
     which is represented by a matrix and a translational part, which is
     described by a vector.
 
-    In this interface, each symmetry operation has a so-called order, which is
-   an
-    unsigned integer describing the number of times a symmetry operation
-    has to be applied to an object until it is identical.
+    In this interface, each symmetry operation has a so-called order,
+    which is an unsigned integer describing the number of times a
+    symmetry operation has to be applied to an object until it is identical.
 
     Furthermore, each symmetry operation has a string-identifier. It contains
-   the
-    Jones faithful representation of the operation, as it is commonly used in
-    many crystallographic programs and of course the International Tables
+    the Jones faithful representation of the operation, as it is commonly used
+    in many crystallographic programs and of course the International Tables
     for Crystallography, where the symmetry operations and their representations
     may be found [1].
 
     The Jones faithful notation is a very concise way of describing
-   matrix/vector pairs.
-    The matrix/vector pair of a two-fold rotation axis along z is for example:
+    matrix/vector pairs. The matrix/vector pair of a two-fold rotation
+    axis along z is for example:
 
         Matrix      Vector
-       -1  0  0     0
-        0 -1  0     0
-        0  0  1     0
+        -1  0  0     0
+         0 -1  0     0
+         0  0  1     0
 
-    This is described by the symbol '-x,-y,z'. If it were a 2_1 screw axis in
-   the same
-    direction, the matrix/vector pair would look like this:
+    This is described by the symbol '-x,-y,z'. If it were a 2_1 screw axis
+    in the same direction, the matrix/vector pair would look like this:
 
         Matrix      Vector
-       -1  0  0     0
-        0 -1  0     0
-        0  0  1    1/2
+        -1  0  0     0
+         0 -1  0     0
+         0  0  1    1/2
 
     And this is represented by the string '-x,-y,z+1/2'. In hexagonal systems
-   there
-    are often operations involving 1/3 or 2/3, so the translational part is kept
-   as
-    a vector of rational numbers in order to carry out precise calculations. For
-   details,
-    see the class V3R.
+    there are often operations involving 1/3 or 2/3, so the translational part
+    is kept as a vector of rational numbers in order to carry out precise
+    calculations. For details, see the class Kernel::V3R.
 
     Using the symmetry operations in code is easy, since
-   SymmetryOperationSymbolParser is
-    automatically called by the string-based constructor of SymmetryOperation
-   and the multiplication
-    operator is overloaded:
+    SymmetryOperationSymbolParser is automatically called by the string-based
+    constructor of SymmetryOperation and the multiplication operator
+    is overloaded:
 
         SymmetryOperation inversion("-x,-y,-z");
         V3D hklPrime = inversion * V3D(1, 1, -1); // results in -1, -1, 1
@@ -67,8 +61,7 @@ namespace Geometry {
     multiplied with and V3R can be added to (for example V3R, V3D).
 
     A special case is the multiplication of several symmetry operations, which
-   can
-    be used to generate new operations:
+    can be used to generate new operations:
 
         SymmetryOperation inversion("-x,-y,-z");
         SymmetryOperation identity = inversion * inversion;
@@ -77,11 +70,11 @@ namespace Geometry {
     the interval (0, 1] when two symmetry operations are combined.
 
     Constructing a SymmetryOperation object from a string is heavy, because the
-   string
-    has to be parsed every time. It's preferable to use the available factory:
+    string has to be parsed every time. It's preferable to use
+    the available factory:
 
         SymmetryOperation inversion =
-   SymmetryOperationFactory::Instance().createSymOp("-x,-y,-z");
+            SymmetryOperationFactory::Instance().createSymOp("-x,-y,-z");
 
     It stores a prototype of the created operation and copy constructs a new
     instance on subsequent calls with the same string.
@@ -90,7 +83,7 @@ namespace Geometry {
 
     References:
         [1] International Tables for Crystallography, Volume A, Fourth edition,
-   pp 797-798.
+            pp 797-798.
 
 
       @author Michael Wedel, Paul Scherrer Institut - SINQ
@@ -116,8 +109,6 @@ namespace Geometry {
     File change history is stored at: <https://github.com/mantidproject/mantid>
     Code Documentation is available at: <http://doxygen.mantidproject.org>
   */
-class SymmetryOperation;
-
 class MANTID_GEOMETRY_DLL SymmetryOperation {
 public:
   SymmetryOperation();

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationFactory.h

@@ -13,7 +13,8 @@
 
 namespace Mantid {
 namespace Geometry {
-/** SymmetryOperationFactory
+/**
+  @class SymmetryOperationFactoryImpl
 
   A factory for symmetry operations. Symmetry operations are stored
   with respect to their identifier (see SymmetryOperation for details).
@@ -21,7 +22,7 @@ namespace Geometry {
   Creation of symmetry operations is then performed like this:
 
       SymmetryOperations inversion =
-  SymmetryOperationFactory::Instance().createSymOp("x,y,z");
+          SymmetryOperationFactory::Instance().createSymOp("x,y,z");
 
   Creating a symmetry operation object automatically registers the object
   as a prototype and subsequent creations are much more efficient because

Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationSymbolParser.h

@@ -8,7 +8,8 @@
 namespace Mantid {
 namespace Geometry {
 
-/** SymmetryOperationSymbolParser :
+/**
+  @class SymmetryOperationSymbolParser
 
   This is a parser for symmetry operation symbols in the Jones
   faithful representation. It creates matrix and a vector component

Code/Mantid/Framework/Geometry/src/Crystal/BraggScatterer.cpp

@@ -52,9 +52,8 @@ bool BraggScatterer::isPropertyExposedToComposite(Property *property) const {
  * Exposes the property with the supplied name to BraggScattererComposite
  *
  * When a property is marked to be exposed to BraggScattererComposite, the
- *composite
- * also declares this property and tries to propagate the value assigned to the
- * composite's property to all its members.
+ * composite also declares this property and tries to propagate the value
+ * assigned to the composite's property to all its members.
  *
  * @param propertyName :: Name of the parameter that should be exposed.
  */

Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererFactory.cpp

@@ -8,16 +8,12 @@ namespace Geometry {
  * Creates an initialized instance of the desired scatterer class
  *
  * This method tries to construct an instance of the class specified by the
- *"name"-parameter.
- * If it is not found, an exception is thrown (see DynamicFactory::create).
- *Otherwise,
- * the object is initialized. If the second argument is not empty, it is
- *expected
- * to contain a semi-colon separated list of "name=value"-pairs. These pairs
- *need to be
+ * "name"-parameter. If it is not found, an exception is thrown
+ * (see DynamicFactory::create). Otherwise, the object is initialized.
+ * If the second argument is not empty, it is expected to contain a semi-colon
+ * separated list of "name=value"-pairs. These pairs need to be
  * valid input for assigning properties of the created scatterer. See the
- *example in
- * the general class documentation.
+ * example in the general class documentation.
  *
  * @param name :: Class name to construct.
  * @param properties :: Semi-colon separated "name=value"-pairs.

Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererInCrystalStructure.cpp

@@ -95,14 +95,12 @@ void BraggScattererInCrystalStructure::declareProperties() {
  * Additional property processing
  *
  * Takes care of handling new property values, for example for construction of a
- *space group
- * from string and so on.
+ * space group from string and so on.
  *
  * Please note that derived classes should not re-implement this method, as
  * the processing for the base properties is absolutely necessary. Instead, all
- *deriving
- * classes should override the method afterScattererPropertySet, which is called
- * from this method.
+ * deriving classes should override the method afterScattererPropertySet,
+ * which is called from this method.
  */
 void BraggScattererInCrystalStructure::afterPropertySet(
     const std::string &propertyName) {

Code/Mantid/Framework/Geometry/src/Crystal/CompositeBraggScatterer.cpp

@@ -143,11 +143,9 @@ void CompositeBraggScatterer::propagatePropertyToScatterer(
  * Synchronize properties with scatterer members
  *
  * This method synchronizes the properties of CompositeBraggScatterer with the
- *properties
- * of the contained BraggScatterer instances. It adds new properties if required
- * and removed properties that are no longer used (for example because the
- *member that
- * introduced the property has been removed).
+ * properties of the contained BraggScatterer instances. It adds new properties
+ * if required and removed properties that are no longer used (for example
+ * because the member that introduced the property has been removed).
  */
 void CompositeBraggScatterer::redeclareProperties() {
   std::map<std::string, size_t> propertyUseCount = getPropertyCountMap();