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

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

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

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).

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(

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]

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) {