diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScatterer.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScatterer.h
index ffcf6ba955ed6a28514528c55695b25f497b3e87..c87a838f4cd5efd0c6a59e54b8e9b4c603282725 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScatterer.h
+++ b/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();
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererFactory.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererFactory.h
index e2f212f521a09af73637621b9bf6bbae3f95a346..1b98b0eacd299f18d22ffa93b35166fa0f4b1721 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererFactory.h
+++ b/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.
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererInCrystalStructure.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererInCrystalStructure.h
index f27e066cce8a3e267cec3cb0db04aad3616c5084..67a1fdcd2deb2018038246e57c3951ba1d57df24 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/BraggScattererInCrystalStructure.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CenteringGroup.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CenteringGroup.h
index 5bea640404bbe6c46bd001b69dd84faae9e782d2..ce3610842e5c939fde96cf7e5d733fe14956f442 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CenteringGroup.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CompositeBraggScatterer.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CompositeBraggScatterer.h
index 8838776303310b965172ab62c43c9d9a934c7ed4..d1e23c735bba3d934b2d65cc15068487c12c318b 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CompositeBraggScatterer.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CrystalStructure.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CrystalStructure.h
index 0f7d308e8519c60e81f49853563e0bbea5d2c29f..24d279a0d68867f21a7aadccab7a3894963df011 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CrystalStructure.h
+++ b/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.
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CyclicGroup.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CyclicGroup.h
index 30610a346c0c64cbc6f8d7041732e968e68bf62d..da968d3410c27b01f68f3ff10347c09fa6e92bfd 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/CyclicGroup.h
+++ b/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.
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/Group.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/Group.h
index 7896cc29a63b72088d3229a615df8606c51d25a1..248dca7b95ddbed494484890ab1a289ec9eb3fe9 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/Group.h
+++ b/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,
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/IsotropicAtomBraggScatterer.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/IsotropicAtomBraggScatterer.h
index 57d77e12650a2fd1d303a05a47a121951c386c14..0a243f40c6a964250adddfd185533c9bee325f4f 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/IsotropicAtomBraggScatterer.h
+++ b/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:
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/PointGroupFactory.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/PointGroupFactory.h
index 16017ad7c252225a9dbcfd4bbd790d52a1108963..edb6fde5ce59f1ce93f9f8af9c0f2cfcdf971dfe 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/PointGroupFactory.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ProductOfCyclicGroups.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ProductOfCyclicGroups.h
index eff12fae2556a291ac4decc70b5c62cb36a243b8..4a7b49fc2e9387af3d1165afe09f57bbe1aa729d 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/ProductOfCyclicGroups.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroup.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroup.h
index df4691de5bfdcd69b4f98fee51b414ab9078bb44..654f3b40279ee42d46a457ceea54d3250d773b0b 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroup.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroupFactory.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroupFactory.h
index e7ef26a4e32e9f286a198a515f8023a7d7101e52..df07af3307d5327d92f02c486a8206a1e7d3adaa 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SpaceGroupFactory.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperation.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperation.h
index 1c0e60eac0f7a21112805ad34b7495cedfaadf0e..7e8bfa04fa290354ef64f327437518c05dcb45d1 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperation.h
+++ b/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();
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationFactory.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationFactory.h
index 41e5eb0d1c7568db376a4a358bae124f5444893d..eabe3833aea905a12a8c8e4c174800ff5ec768d1 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationFactory.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationSymbolParser.h b/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationSymbolParser.h
index 6cb88453e0d1fa894320d3f847acb8a9e25af173..bca3a319af26c48369333338db0b7ecf1eba53ba 100644
--- a/Code/Mantid/Framework/Geometry/inc/MantidGeometry/Crystal/SymmetryOperationSymbolParser.h
+++ b/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
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/BraggScatterer.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/BraggScatterer.cpp
index 2f433c0d18aff0221944b93ad6cd351c18737b87..1941d8f6fdb7480128458a0eaf10879d6c56693f 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/BraggScatterer.cpp
+++ b/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.
*/
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererFactory.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererFactory.cpp
index 929e94293e9aeb486043b4a232182266bafde20c..14a4e4bd97f51c4935e6c1e9c48066474d52abf4 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererFactory.cpp
+++ b/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.
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererInCrystalStructure.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererInCrystalStructure.cpp
index 52077d24476690184a8f99739eebfad9b5ea78f4..a442625405aacd20d49e345a7346a63784877271 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/BraggScattererInCrystalStructure.cpp
+++ b/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) {
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/CompositeBraggScatterer.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/CompositeBraggScatterer.cpp
index f7dac1ff02266e70701039cad866bf146a1e78db..077dd92c7595722a79b7bbff7b79cc4dc54b6395 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/CompositeBraggScatterer.cpp
+++ b/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();
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/IsotropicAtomBraggScatterer.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/IsotropicAtomBraggScatterer.cpp
index fc5614779f99ea42f88576adde403ed59b71211d..80e8f54eebf9e9ee47577303faec65ba32b13883 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/IsotropicAtomBraggScatterer.cpp
+++ b/Code/Mantid/Framework/Geometry/src/Crystal/IsotropicAtomBraggScatterer.cpp
@@ -57,8 +57,8 @@ double IsotropicAtomBraggScatterer::getU() const { return getProperty("U"); }
* Calculates the structure factor
*
* This method calculates the structure factor, taking into account
- *contributions from all
- * atoms on the stored position _and all symmetrically equivalent_.
+ * contributions from all atoms on the stored position
+ * _and all symmetrically equivalent_.
* For details, please refer to the class documentation in the header file.
*
* @param hkl :: HKL for which the structure factor should be calculated
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/PointGroup.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/PointGroup.cpp
index 86a905f685615bd9695574e078bf0f09fd0acd86..7056668b20fb17ad7f3a505796788b11ac51471a 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/PointGroup.cpp
+++ b/Code/Mantid/Framework/Geometry/src/Crystal/PointGroup.cpp
@@ -64,10 +64,8 @@ std::string PointGroup::getSymbol() const { return m_symbolHM; }
*
* This method applies all transformation matrices to the supplied hkl and puts
* it into a set, which is returned in the end. Using a set ensures that each
- *hkl
- * occurs once and only once. This set is the set of equivalent hkls, specific
- *to
- * a concrete point group.
+ * hkl occurs once and only once. This set is the set of equivalent hkls,
+ * specific to a concrete point group.
*
* The symmetry operations need to be set prior to calling this method by a call
* to PointGroup::setTransformationMatrices.
@@ -115,25 +113,23 @@ std::vector<SymmetryOperation> PointGroup::getSymmetryOperations() const {
* Returns all symmetry operations generated by a list of symmetry operations
*
* This method takes a vector of symmetry operations and returns the resulting
- *set of
- * symmetry operations. It does so by applying the first symmetry operation
- *(order - 1) times
- * to an identity operation which results in a list of (order - 1) matrices.
- *Then it multiplies
- * the second operation to all these operations, and so on.
+ * set of symmetry operations. It does so by applying the first symmetry
+ * operation (order - 1) times to an identity operation which results in a list
+ * of (order - 1) matrices. Then it multiplies the second operation to all these
+ * operations, and so on.
*
* Using this method, all point groups can be described using a maximum of four
* symmetry operations. m-3m for example, which is defined in PointGroupLaue13,
* needs only four symmetry operations to generate all 48 transformation
- *matrices.
+ * matrices.
* It does not matter which symmetry operations are chosen, as long
* as the chosen set generates all (but not more than) present in the point
- *group. For 2/m, one
- * could for example either choose (m and 2) or (m and -1) or (2 and -1).
+ * group. For 2/m, one could for example either choose (m and 2)
+ * or (m and -1) or (2 and -1).
*
* All 32 point groups can be found in:
* International Tables for Crystallography A, 2006, pp. 770 - 790 (Table
- *10.1.2.2)
+ * 10.1.2.2)
*
* @param symmetryOperations
* @return
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroup.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroup.cpp
index 213b81774b1e87163477771c842dd01e77827fee..aa1b30cf9792a922e15afa62c6d0747e0db4027a 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroup.cpp
+++ b/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroup.cpp
@@ -9,8 +9,7 @@ namespace Geometry {
* This constructor creates a space group with the symmetry operations contained
* in the Group-parameter and assigns the given number and symbol.
*
- * @param itNumber :: Space group number according to International Tables for
- *Crystallography A
+ * @param itNumber :: Space group number (ITA)
* @param hmSymbol :: Herman-Mauguin symbol for the space group
* @param group :: Group that contains all symmetry operations (including
*centering).
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroupFactory.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroupFactory.cpp
index 54a07d94f9de8db5fc8f857ba7d81d90fe654af7..325f8f321f415e4c4e3cc72e8132e19cb3a0e8bf 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroupFactory.cpp
+++ b/Code/Mantid/Framework/Geometry/src/Crystal/SpaceGroupFactory.cpp
@@ -51,7 +51,7 @@ SpaceGroup_const_sptr AbstractSpaceGroupGenerator::getPrototype() {
*
* Constructs a space group object using a Group generated by the pure virtual
* generateGroup()-method along with the stored number and
- *Hermann-Mauguin-symbol.
+ * Hermann-Mauguin-symbol.
*
* generateGroup() has to be implemented by sub-classes and should probably use
* the generatorInformation supplied to the constructor.
@@ -201,22 +201,18 @@ void SpaceGroupFactoryImpl::unsubscribeSpaceGroup(const std::string &hmSymbol) {
* Subscribes a space group into the factory using generators
*
* With this method one can register a space group that is generated by an
- *algorithm
- * based on the instructions in [1]. Currently it's important that the Herrman-
- * Mauguin symbol starts with an upper case letter, because that is used to
- *generate
- * centering translations (it should be upper case anyway).
+ * algorithm based on the instructions in [1]. Currently it's important that
+ * the Herrman-Mauguin symbol starts with an upper case letter, because that is
+ * used to generate centering translations (it should be upper case anyway).
*
* The method will throw an exception if the number or symbol is already
- *registered.
+ * registered.
*
* [1] Shmueli, U. Acta Crystallogr. A 40, 559–567 (1984).
* http://dx.doi.org/10.1107/S0108767384001161
*
- * @param number :: Space group number according to International Tables for
- *Crystallography A
+ * @param number :: Space group number (ITA)
* @param hmSymbol :: Herrman-Mauguin symbol with upper case first letter
- *(centering).
* @param generators :: Generating symmetry operations.
*/
void SpaceGroupFactoryImpl::subscribeGeneratedSpaceGroup(
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperation.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperation.cpp
index a5270bd12bf5a2e44ea64da61158eeed1441668a..1776a9a77d7fa933bb1d2893fa88c38e05753bf7 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperation.cpp
+++ b/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperation.cpp
@@ -19,12 +19,10 @@ SymmetryOperation::SymmetryOperation()
* Construct a symmetry operation from a Jones faithful representation
*
* This method invokes SymmetryOperationSymbolParser and tries to parse the
- *supplied string.
- * Please not that parsing this string is not very efficient. If you have to
- *create the same
- * operations very often, use SymmetryOperationFactory, which works with the
- *copy constructor
- * - it's orders of magnitude faster.
+ * supplied string. Please not that parsing this string is not very efficient.
+ * If you have to create the same operations very often, use
+ * SymmetryOperationFactory, which works with the copy constructor - it's orders
+ * of magnitude faster.
*
* @param identifier :: Jones faithful representation of a symmetry operation
*/
@@ -193,10 +191,9 @@ SymmetryOperation::getOrderFromMatrix(const Kernel::IntMatrix &matrix) const {
* Wraps a V3R to the interval (0, 1]
*
* For certain crystallographic calculations it is necessary to constrain
- *fractional
- * coordinates to the unit cell, for example to generate all atomic positions
- * in the cell. In this context, the fractional coordinate -0.45 is equal to
- * "0.55 of the next cell", so it's transformed to 0.55.
+ * fractional coordinates to the unit cell, for example to generate all
+ * atomic positions in the cell. In this context, the fractional coordinate
+ * -0.45 is equal to "0.55 of the next cell", so it's transformed to 0.55.
*
* @param vector :: Input vector with arbitrary numbers.
* @return Vector with components on the interval (0, 1]
diff --git a/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperationSymbolParser.cpp b/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperationSymbolParser.cpp
index 28fee8c55503f6a95cb5fa280a750e926ae86f43..24fedd2e69ec9568e46c4d92ae7ab526d39bcb4d 100644
--- a/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperationSymbolParser.cpp
+++ b/Code/Mantid/Framework/Geometry/src/Crystal/SymmetryOperationSymbolParser.cpp
@@ -14,24 +14,21 @@ SymmetryOperationSymbolParser::SymmetryOperationSymbolParser() {}
* Tries to parse the given symbol
*
* This method tries to parse a given symbol and returns the matrix/vector pair
- *resulting from
- * the parsing process. It takes a string representing a symmetry operation in
- *the format:
+ * resulting from the parsing process. It takes a string representing a
+ * symmetry operation in the format:
* x+a/b, -y-c/d, e/f-z
* where x, y and z are the literals 'x', 'y' and 'z', while a-f are integers,
- *representing
- * rational numbers. The latter don't need to be present, a string "x,y,z" is
- *valid. Leading plus-signs
- * may be included if desired, so that "+x,+y,+z" is also valid.
+ * representing rational numbers. The latter don't need to be present,
+ * a string "x,y,z" is valid. Leading plus-signs may be included if desired,
+ * so that "+x,+y,+z" is also valid.
*
* If there is a problem, a Kernel::Exception::ParseError exception is thrown.
*
* See also SymmetryOperationSymbolParser::getNormalizedIdentifier, which
- *performs the opposite operation.
+ * performs the opposite operation.
*
* @param identifier :: Symbol representing a symmetry operation
- * @return Pair of Kernel::IntMatrix and V3R, representing the symmetry
- *operation.
+ * @return Kernel::IntMatrix and V3R, representing the symmetry operation.
*/
std::pair<Kernel::IntMatrix, V3R>
SymmetryOperationSymbolParser::parseIdentifier(const std::string &identifier) {