Refs #3867. Fixing doxygen warnings.

Code/Mantid/Framework/DataObjects/inc/MantidDataObjects/PeaksWorkspace.h

@@ -107,7 +107,7 @@ namespace DataObjects
 
     //---------------------------------------------------------------------------------------------
     /** Add a peak to the list
-     * @param peak :: Peak object to add (copy) into this.
+     * @param ipeak :: Peak object to add (copy) into this.
      */
     void addPeak(const API::IPeak& ipeak)
     {

Code/Mantid/Framework/DataObjects/src/Peak.cpp

@@ -141,7 +141,7 @@ namespace DataObjects
   //----------------------------------------------------------------------------------------------
   /** Constructor making a Peak from IPeak interface
    *
-   * @param ipeak :: const reference to an IPeak object
+   * @param peak :: const reference to an IPeak object
    * @return
    */
   Peak::Peak(const Peak & peak):
@@ -683,7 +683,7 @@ namespace DataObjects
   // -------------------------------------------------------------------------------------
   /** Helper function for displaying/sorting peaks in MantidPlot
    *
-   * @param name :: name of the column in the table workspace
+   * @param name_in :: name of the column in the table workspace
    * @return a double representing that value (if that's possible)
    * @throw std::runtime_error if you asked for a column that can't convert to double.
    */

Code/Mantid/Framework/DataObjects/src/PeaksWorkspace.cpp

@@ -81,7 +81,6 @@ namespace DataObjects
   //---------------------------------------------------------------------------------------------
   /** Clone a shared pointer
    *
-   * @param other :: other PeaksWorkspace to copy from
    * @return copy of the peaksworkspace
    */
   boost::shared_ptr<PeaksWorkspace> PeaksWorkspace::clone()

Code/Mantid/Framework/DataObjects/src/SpecialWorkspace2D.cpp

@@ -130,6 +130,7 @@ namespace DataObjects
   /** Return the special value (Y) in the workspace at the given detector ID
    *
    * @param detectorID :: detector ID to look up
+   * @param value :: holder for the Y value
    * @return the Y value for that detector ID.
    * @throw std::invalid_argument if the detector ID was not found
    */

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

@@ -2147,6 +2147,7 @@ int IndexingUtils::NumberIndexed_3D( const V3D               & a_dir,
                         to count the peak as indexed by UB.
   @param miller_indices This vector returns a list of Miller Indices, with 
                         one entry for each given Q vector. 
+  @param ave_error      The average error from all lattice directions.
 
   @return A non-negative integer giving the number of peaks indexed by UB,
           within the specified tolerance on h,k,l. 
@@ -2298,7 +2299,7 @@ int IndexingUtils::GetIndexedPeaks_1D( const V3D              & direction,
   @param required_tolerance  The maximum allowed error (as a faction of
                              the corresponding Miller index) for a peak
                              q_vector to be counted as indexed.
-  @param index_vals          List of the Miller indices (h,k,l) of peaks
+  @param miller_indices      List of the Miller indices (h,k,l) of peaks
                              that were indexed in all specified directions.
   @param indexed_qs          List of Qxyz value for the peaks that were
                              indexed indexed in all specified directions.
@@ -2385,7 +2386,7 @@ int IndexingUtils::GetIndexedPeaks_3D( const V3D              & direction_1,
   @param required_tolerance  The maximum allowed error (as a faction of
                              the corresponding Miller index) for a peak
                              q_vector to be counted as indexed.
-  @param index_vals          List of the Miller indices (h,k,l) of peaks
+  @param miller_indices      List of the Miller indices (h,k,l) of peaks
                              that were indexed in all specified directions.
   @param indexed_qs          List of Qxyz value for the peaks that were
                              indexed indexed in all specified directions.
@@ -2516,6 +2517,8 @@ std::vector<V3D> IndexingUtils::MakeHemisphereDirections( int n_steps )
   which form the specified angle with the specified axis. 
 
   @param n_steps   The number of vectors to generate around the circle. 
+  @param axis      The specified axis
+  @param angle_degrees  The specified angle
 
   @return A std::vector containing direction vectors forming the same angle
           with the axis.

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

@@ -28,8 +28,11 @@ namespace Geometry
   }
 
   /** Constructor
-  @param _a, _b, _c :: lattice parameters \f$ a, b, c \f$ \n
-  with \f$\alpha = \beta = \gamma = 90^\circ \f$*/      
+  @param _a :: lattice parameter \f$ a \f$ with \f$\alpha = \beta = \gamma = 90^\circ \f$
+  @param _b :: lattice parameter \f$ b \f$ with \f$\alpha = \beta = \gamma = 90^\circ \f$
+  @param _c :: lattice parameter \f$ c \f$ with \f$\alpha = \beta = \gamma = 90^\circ \f$
+  @param Umatrix :: orientation matrix U
+  */
   OrientedLattice::OrientedLattice(const double _a,const double _b,const double _c,DblMatrix Umatrix):UnitCell(_a,_b,_c)
   {
     if (Umatrix.isRotation()==true)
@@ -41,8 +44,14 @@ namespace Geometry
   }
 
   /** Constructor
-  @param _a, _b, _c, _alpha, _beta, _gamma :: lattice parameters\n
+  @param _a :: lattice parameter \f$ a \f$
+  @param _b :: lattice parameter \f$ b \f$
+  @param _c :: lattice parameter \f$ c \f$
+  @param _alpha :: lattice parameter \f$ \alpha \f$
+  @param _beta :: lattice parameter \f$ \beta \f$
+  @param _gamma :: lattice parameter \f$ \gamma \f$
   @param angleunit :: units for angle, of type #AngleUnits. Default is degrees.
+  @param Umatrix :: orientation matrix U
   */
   OrientedLattice::OrientedLattice(const double _a,const double _b,const double _c,const double _alpha,const double _beta,const double _gamma,DblMatrix Umatrix, const int angleunit):UnitCell(_a,_b,_c,_alpha,_beta,_gamma,angleunit)
   {

Code/Mantid/Framework/Geometry/src/Instrument/Component.cpp

@@ -564,7 +564,7 @@ namespace Geometry
 
   //------------------------------------------------------------------------------------------------
   /** Append to an open XML string
-   * @param xml :: string to append to. */
+   * @param xmlStream :: string to append to. */
   void Component::appendXML(std::ostream& xmlStream) const
   {
     xmlStream << "<pos>";

Code/Mantid/Framework/Geometry/src/Instrument/Detector.cpp

@@ -24,6 +24,7 @@ Detector::Detector(const Detector* base, const ParameterMap * map)
 
 /** Constructor
  *  @param name :: The name of the component
+ *  @param id :: Index for the component
  *  @param parent :: The parent component
  */
 Detector::Detector(const std::string& name, int id, IComponent* parent) :
@@ -33,6 +34,7 @@ Detector::Detector(const std::string& name, int id, IComponent* parent) :
 
 /** Constructor
  *  @param name :: The name of the component
+ *  @param id :: Index for the component
  *  @param shape ::  A pointer to the object describing the shape of this component
  *  @param parent :: The parent component
  */

Code/Mantid/Framework/Geometry/src/Instrument/NearestNeighbours.cpp

@@ -31,9 +31,9 @@ namespace Mantid
 
     /**
      * Returns a map of the spectrum numbers to the distances for the nearest neighbours.
-     * @param component :: IComponent pointer to Detector object
-     * @param noNeighbours :: Number of neighbours to search for
+     * @param spectrum :: Spectrum ID of the central pixel
      * @param force :: flag to indicate that the nearest neighbours map should be rebult by force. Otherwise will only call build when different.
+     * @param noNeighbours :: Number of neighbours to search for
      * @return map of Detector ID's to distance
      * @throw NotFoundError if component is not recognised as a detector
      */
@@ -48,7 +48,7 @@ namespace Mantid
 
     /**
      * Returns a map of the spectrum numbers to the distances for the nearest neighbours.
-     * @param component :: IComponent pointer to Detector object
+     * @param spectrum :: Spectrum ID of the central pixel
      * @param radius :: cut-off distance for detector list to returns
      * @return map of Detector ID's to distance
      * @throw NotFoundError if component is not recognised as a detector

Code/Mantid/Framework/Geometry/src/Instrument/XMLlogfile.cpp

@@ -34,6 +34,7 @@ namespace Mantid
     *  @param constraint :: The constraint associated with this parameter
     *  @param penaltyFactor :: The level of penalty associated with the constraint
     *  @param fitFunc :: What fit function this applies to
+    *  @param angleConvertConst :: angle conversion constant?????
     */
     XMLlogfile::XMLlogfile(const std::string& logfileID, const std::string& value, const boost::shared_ptr<Kernel::Interpolation>& interpolation, 
       const std::string& formula, const std::string& formulaUnit, const std::string& resultUnit, const std::string& paramName, 

Code/Mantid/Framework/Geometry/src/MDGeometry/MDPlane.cpp

@@ -89,38 +89,6 @@ namespace Geometry
 
 
 //  //----------------------------------------------------------------------------------------------
-//  /** Constructor with N points on the plane's surface.
-//   *
-//   * A hyperplane is defined as:
-//   *  a1*x1 + a2*x2 + ... = b
-//   *
-//   * We have N "x" points describing points on the surface
-//   *  a1*x11 + a2*x12 + ... = b
-//   *  a1*x21 + a2*x22 + ... = b
-//   *
-//   * Let us reset the origin by offsetting all points by - x1 so that the first point is 0,0,0...
-//   * This allows us to set b = 0
-//   *  0 + 0 = 0
-//   *  a1 * (x21-x11) + a2 * (x22-x12) + ... = 0
-//   *  a1 * (x31-x11) + a2 * (x32-x12) + ... = 0
-//   *
-//   * We can divide by a1 to reduce the problems to N-1 equations with N-1 variables
-//   *  1 * (x21-x11) + a2/a1 * (x22-x12) + ... = 0
-//   *  1 * (x31-x11) + a2/a1 * (x32-x12) + ... = 0
-//   *      ...
-//   *
-//   * Or, expressed as a matrix A x = B
-//   *
-//   * A x = | x22 x23 | | a2/a1 | = B = | -x21 |
-//   *       | x32 x33 | | a3/a1 |       | -x31 |
-//   *
-//   * (where i've offset x22 etc. already)
-//   * We can take a1 = 1 since it doesn't matter: we'll calculate b later.
-//   *
-//   * @param points :: vector of N points with N dimensions.
-//   * @param insidePoint :: coordinate of a point that is known to be inside the plane described
-//   * @throws GSL error if the matrix cannot be solved (singular, etc.)
-//   */
 //  MDPlane::MDPlane(const std::vector<Mantid::Kernel::VMD> & points, const VMD & insidePoint)
 //  {
 //    if (points.size() <= 0)

Code/Mantid/Framework/Geometry/src/Math/PolygonEdge.cpp

@@ -24,7 +24,7 @@ namespace Mantid
     /**
      * Create a point a given fraction along this edge
      * @param fraction :: The fraction of the current edge
-     * @param returns A point on the edge
+     * @returns A point on the edge
      */
     Kernel::V2D PolygonEdge::point(const double fraction) const
     {
@@ -78,7 +78,7 @@ namespace Mantid
     * Calculate the orientation type of this edge with another.
     * @param focusEdge :: A reference to the PolygonEdge to test
     * @param refEdge :: A reference to another PolygonEdge object to compare with
-    * @param t[Out] :: If an intersection is found this value is set to the ratio
+    * @param t [Out] :: If an intersection is found this value is set to the ratio
     * of the dot products between the normal to the other line
     * @returns An enumeration denoting the orientation type
     */
@@ -109,7 +109,7 @@ namespace Mantid
     * Calculate the crossing point of this edge with another
     * @param edgeOne :: The first polygon edge
     * @param edgeTwo :: The second polygon edge
-    * @param crossPoint[Out] :: If found the point of intersection is filled here
+    * @param crossPoint [Out] :: If found the point of intersection is filled here
     */
     PolygonEdge::Orientation crossingPoint(const PolygonEdge & edgeOne, const PolygonEdge & edgeTwo, V2D & crossPoint)
     {
@@ -165,7 +165,8 @@ namespace Mantid
      * Return if the edges aim at each other
      * @param a :: First edge
      * @param b :: Second edge
-     * @param pclass :: The point classification of a point on edge a
+     * @param aclass :: The point classification of a point on edge a
+     * @param crossType :: The edge orientation classification
      */
     bool edgeAimsAt(const PolygonEdge &a, const PolygonEdge &b, PointClassification aclass, PolygonEdge::Orientation crossType)
     {

Code/Mantid/Framework/Geometry/src/Objects/Track.cpp

@@ -24,11 +24,11 @@ namespace Mantid
 
     /**
     * Constructor
-    * @param startPoint :: Initial point
-    * @param direction :: Directional vector. It must be unit vector.
+    * @param startPt :: Initial point
+    * @param unitVector :: Directional vector. It must be unit vector.
     */ 
-    Track::Track(const V3D& startPoint, const V3D& direction) : 
-    m_startPoint(startPoint),m_unitVector(direction)
+    Track::Track(const V3D& startPt, const V3D& unitVector) :
+    m_startPoint(startPt),m_unitVector(unitVector)
     {}
 
     /**
@@ -152,29 +152,29 @@ namespace Mantid
      * The points are kept in order
      * @param directionFlag :: A flag indicating if the direction of travel is entering/leaving
      * an object. +1 is entering, -1 is leaving.
-     * @param point :: Point of intersection
+     * @param endPoint :: Point of intersection
      * @param compID :: ID of the component that this link is about (Default=NULL)
      */
-    void Track::addPoint(const int directionFlag, const V3D& point, const ComponentID compID) 
+    void Track::addPoint(const int directionFlag, const V3D& endPoint, const ComponentID compID)
     {
-      IntersectionPoint newPoint(directionFlag, point, point.distance(m_startPoint), compID);
+      IntersectionPoint newPoint(directionFlag, endPoint, endPoint.distance(m_startPoint), compID);
       PType::iterator lowestPtr = std::lower_bound(m_surfPoints.begin(), m_surfPoints.end(), newPoint);
       m_surfPoints.insert(lowestPtr, newPoint);
     }
 
     /**
     * This adds a whole segment to the track : This currently assumes that links are added in order
-    * @param startPoint :: first Point
-    * @param endPoint :: second Point
-    * @param distAlongTrack :: Distance along track
+    * @param firstPoint :: first Point
+    * @param secondPoint :: second Point
+    * @param distanceAlongTrack :: Distance along track
     * @param compID :: ID of the component that this link is about (Default=NULL)
     * @retval Index of link within the track
     */
-    int Track::addLink(const V3D& startPoint, const V3D& endPoint,
-      const double distAlongTrack, const ComponentID compID)
+    int Track::addLink(const V3D& firstPoint, const V3D& secondPoint,
+      const double distanceAlongTrack, const ComponentID compID)
     {
       // Process First Point
-      Link newLink(startPoint,endPoint,distAlongTrack,compID);
+      Link newLink(firstPoint,secondPoint,distanceAlongTrack,compID);
       int index(0);
       if( m_links.empty() )
       {

Code/Mantid/Framework/Kernel/inc/MantidKernel/ThreadSchedulerMutexes.h

@@ -129,6 +129,7 @@ namespace Kernel
     /** Signal to the scheduler that a task is complete.
      *
      * @param task :: the Task that was completed.
+     * @param threadnum :: unused argument
      */
     virtual void finished(Task * task, size_t threadnum)
     {

Code/Mantid/Framework/Kernel/inc/MantidKernel/TimeSeriesProperty.h

@@ -481,8 +481,8 @@ class DLLExport TimeSeriesProperty: public Property
 
   //-----------------------------------------------------------------------------------------------
   /** Adds vectors of values to the map. Should be much faster than repeated calls to addValue.
-   *  @param time :: The time as a boost::posix_time::ptime value
-   *  @param value :: The associated value
+   *  @param times :: The time as a boost::posix_time::ptime value
+   *  @param values :: The associated value
    */
   void addValues(const std::vector<Kernel::DateAndTime> &times,
       const std::vector<TYPE> & values)

Code/Mantid/Framework/Kernel/inc/MantidKernel/VMD.h

@@ -70,7 +70,9 @@ namespace Kernel
 
     //-------------------------------------------------------------------------------------------
     /** 2D Constructor
-     * @param valX :: value at this dimension*/
+     * @param val0 :: value at first dimension
+     * @param val1 :: value at second dimension
+     */
     VMD(double val0, double val1)
     : nd(2)
     {
@@ -81,7 +83,10 @@ namespace Kernel
 
     //-------------------------------------------------------------------------------------------
     /** 3D Constructor
-     * @param valX :: value at this dimension*/
+     * @param val0 :: value at first dimension
+     * @param val1 :: value at second dimension
+     * @param val2 :: value at third dimension
+     */
     VMD(double val0, double val1, double val2)
     : nd(3)
     {
@@ -93,7 +98,11 @@ namespace Kernel
 
     //-------------------------------------------------------------------------------------------
     /** 4D Constructor
-     * @param valX :: value at this dimension*/
+     * @param val0 :: value at first dimension
+     * @param val1 :: value at second dimension
+     * @param val2 :: value at third dimension
+     * @param val3 :: value at fourth dimension
+     */
     VMD(double val0, double val1, double val2, double val3)
     : nd(4)
     {
@@ -106,7 +115,12 @@ namespace Kernel
 
     //-------------------------------------------------------------------------------------------
     /** 5D Constructor
-     * @param valX :: value at this dimension*/
+     * @param val0 :: value at first dimension
+     * @param val1 :: value at second dimension
+     * @param val2 :: value at third dimension
+     * @param val3 :: value at fourth dimension
+     * @param val4 :: value at fifth dimension
+     */
     VMD(double val0, double val1, double val2, double val3, double val4)
     : nd(5)
     {
@@ -120,7 +134,13 @@ namespace Kernel
 
     //-------------------------------------------------------------------------------------------
     /** 6D Constructor
-     * @param valX :: value at this dimension*/
+     * @param val0 :: value at first dimension
+     * @param val1 :: value at second dimension
+     * @param val2 :: value at third dimension
+     * @param val3 :: value at fourth dimension
+     * @param val4 :: value at fifth dimension
+     * @param val5 :: value at sixth dimension
+     */
     VMD(double val0, double val1, double val2, double val3, double val4, double val5)
     : nd(6)
     {

Code/Mantid/Framework/Kernel/inc/MantidKernel/VectorHelper.h

@@ -107,6 +107,7 @@ namespace VectorHelper
    * Data type is converted at the same type.
    * @param begin :: iterator at the beginning of the data
    * @param end :: iterator at the end of the data
+   * @param dims_array :: array to hold size of dimensions
    * @return :: a pointer to an array of type T.
    */
   template< typename T, typename _ForwardIterator >
@@ -124,6 +125,7 @@ namespace VectorHelper
    * Data type is converted at the same type.
    * @param begin :: iterator at the beginning of the data
    * @param end :: iterator at the end of the data
+   * @param dims_array :: array to hold size of dimensions
    * @return :: a pointer to an array of type T.
    */
   template< typename T, typename _ForwardIterator >