Tpetra: Fix more doxygen warnings

Signed-off-by: Christian Glusa <caglusa@sandia.gov>

Author: cgcgcg

packages/ifpack2/src/Ifpack2_Details_OverlappingRowGraph_decl.hpp

@@ -210,12 +210,12 @@ class OverlappingRowGraph : virtual public Ifpack2::Details::RowGraph<GraphType>
   /// \param localRow [in] Local index of the row.
   /// \param indices [out] Local column indices in that row that are
   ///   owned by the calling process.
-  /// \param numIndices [out] Number of indices returned in \c gblColInds.
+  /// \param numIndices [out] Number of indices returned in \c indices.
   ///
-  /// This method throws std::runtime_error if \c gblColInds is not large
+  /// This method throws std::runtime_error if \c indices is not large
   /// enough to hold the column indices in row \c localRow.  If row
   /// <tt>localRow</tt> does not belong to this process, then
-  /// <tt>gblColInds</tt> is not modified and \c numIndices is set to
+  /// <tt>indices</tt> is not modified and \c numIndices is set to
   /// Teuchos::OrdinalTraits<size_t>::invalid() on output.
   virtual void
   getLocalRowCopy(local_ordinal_type localRow,

packages/tpetra/core/ext/TpetraExt_MatrixMatrix_decl.hpp

@@ -59,6 +59,8 @@ namespace MatrixMatrix {
 /// \param call_FillComplete_on_result [in] Optional argument;
 ///   defaults to true.  If false, C will <i>not</i> be fill complete
 ///   on output.
+/// \param label [in] Label for \c Teuchos::TimeMonitor.
+/// \param params [in/out] List of parameters.
 template <class Scalar,
           class LocalOrdinal,
           class GlobalOrdinal,
@@ -88,6 +90,7 @@ void Multiply(
 /// \param transposeB [in] Whether to use transpose of matrix B. This is
 ///   currently not implemented.
 /// \param C [in/out] output matrix. Must be null.
+/// \param label [in] Label for \c Teuchos::TimeMonitor.
 template <class Scalar,
           class LocalOrdinal,
           class GlobalOrdinal,
@@ -135,11 +138,11 @@ void Add(
 /// \pre A and B must both be fillComplete and have matching domain and
 ///   range Maps.
 ///
-/// \param scalarA [in] Scalar multiplier for A in the sum.
+/// \param alpha [in] Scalar multiplier for A in the sum.
 /// \param transposeA [in] If true, use the transpose of A.
 /// \param A [in] The first input matrix.
 ///
-/// \param scalarB [in] Scalar multiplier for B in the sum.
+/// \param beta [in] Scalar multiplier for B in the sum.
 /// \param transposeB [in] If true, use the transpose of B.
 /// \param B [in] The second input matrix.
 ///
@@ -186,10 +189,10 @@ add(const Scalar& alpha,
 /// \pre A and B must both be fillComplete and have matching domain and
 ///   range Maps.
 ///
-/// \param scalarA [in] Scalar multiplier for A in the sum.
+/// \param alpha [in] Scalar multiplier for A in the sum.
 /// \param transposeA [in] If true, use the transpose of A.
 /// \param A [in] The first input matrix.
-/// \param scalarB [in] Scalar multiplier for B in the sum.
+/// \param beta [in] Scalar multiplier for B in the sum.
 /// \param transposeB [in] If true, use the transpose of B.
 /// \param B [in] The second input matrix.
 /// \param C [out] The result matrix, which we expect to be 'new' (no entries inserted) on input.
@@ -319,12 +322,14 @@ void Add(
            will be produced when forming the product A*B. On exit,
            C.FillComplete() will have been called, unless the last argument
            to this function is specified to be false.
-  @param call_fillComplete_on_result Optional argument, defaults to true.
+  @param call_FillComplete_on_result Optional argument, defaults to true.
          Power users may specify this argument to be false if they *DON'T*
          want this function to call C.fillComplete. (It is often useful
          to allow this function to call C.fillComplete, in cases where
          one or both of the input matrices are rectangular and it is not
          trivial to know which maps to use for the domain- and range-maps.)
+  @param label [in] Label for \c Teuchos::TimeMonitor.
+  @param params [in/out] List of parameters.
 */
 template <class Scalar,
           class LocalOrdinal,

packages/tpetra/core/ext/TpetraExt_TripleMatrixMultiply_decl.hpp

@@ -53,9 +53,9 @@ namespace TripleMatrixMultiply {
 /// \param R [in] fill-complete sparse matrix.
 /// \param transposeR [in] Whether to use transpose of matrix R.
 /// \param A [in] fill-complete sparse matrix.
-/// \param transposeR [in] Whether to use transpose of matrix A.
+/// \param transposeA [in] Whether to use transpose of matrix A.
 /// \param P [in] fill-complete sparse matrix.
-/// \param transposeB [in] Whether to use transpose of matrix P.
+/// \param transposeP [in] Whether to use transpose of matrix P.
 /// \param Ac [in/out] On entry to this method, if Ac is fill complete,
 ///   then Ac's graph must have the correct structure, that is, its
 ///   structure must equal the structure of R*A*P. (This is currently
@@ -64,6 +64,8 @@ namespace TripleMatrixMultiply {
 /// \param call_FillComplete_on_result [in] Optional argument;
 ///   defaults to true.  If false, C will <i>not</i> be fill complete
 ///   on output.
+/// \param label [in] Label for \c Teuchos::TimeMonitor.
+/// \param params [in/out] List of parameters.
 template <class Scalar,
           class LocalOrdinal,
           class GlobalOrdinal,

packages/tpetra/core/inout/MatrixMarket_Tpetra.hpp

@@ -1589,7 +1589,7 @@ class Reader {
   ///   wait for the final result.
   ///
   /// \param filename [in] Name of the Matrix Market file.
-  /// \param pComm [in] Communicator containing all processor(s)
+  /// \param comm [in] Communicator containing all processor(s)
   ///   over which the sparse matrix will be distributed.
   /// \param callFillComplete [in] Whether to call fillComplete()
   ///   on the Tpetra::CrsMatrix, after adding all the entries
@@ -1886,7 +1886,7 @@ class Reader {
   ///   wait for the final result.
   ///
   /// \param filename [in] Name of the Matrix Market file.
-  /// \param pComm [in] Communicator containing all processor(s)
+  /// \param comm [in] Communicator containing all processor(s)
   ///   over which the sparse matrix will be distributed.
   /// \param callFillComplete [in] Whether to call fillComplete()
   ///   on the Tpetra::CrsMatrix, after adding all the entries
@@ -1927,7 +1927,7 @@ class Reader {
   ///   participate and wait for the final result.
   ///
   /// \param filename [in] Name of the Matrix Market file.
-  /// \param pComm [in] Communicator containing all process(es)
+  /// \param comm [in] Communicator containing all process(es)
   ///   over which the sparse matrix will be distributed.
   /// \param constructorParams [in/out] Parameters for the
   ///   CrsMatrix constructor.
@@ -3768,7 +3768,7 @@ class Reader {
   /// \param debug [in] Whether to produce copious status output
   ///   useful for Tpetra developers, but probably not useful for
   ///   anyone else.
-  /// \param debug [in] If true, read in binary mode.
+  /// \param binary [in] If true, read in binary mode.
   static Teuchos::RCP<multivector_type>
   readDenseFile(const std::string& filename,
                 const trcp_tcomm_t& comm,
@@ -3924,7 +3924,7 @@ class Reader {
   /// \param debug [in] Whether to produce copious status output
   ///   useful for Tpetra developers, but probably not useful for
   ///   anyone else.
-  /// \param debug [in] If true, read in binary mode.
+  /// \param binary [in] If true, read in binary mode.
 
   static Teuchos::RCP<multivector_type>
   readDense(std::istream& in,
@@ -3970,7 +3970,7 @@ class Reader {
   /// \param debug [in] Whether to produce copious status output
   ///   useful for Tpetra developers, but probably not useful for
   ///   anyone else.
-  /// \param debug [in] If true, read in binary mode.
+  /// \param binary [in] If true, read in binary mode.
   static Teuchos::RCP<const map_type>
   readMapFile(const std::string& filename,
               const trcp_tcomm_t& comm,
@@ -5096,7 +5096,7 @@ class Reader {
   /// \param debug [in] Whether to produce copious status output
   ///   useful for Tpetra developers, but probably not useful for
   ///   anyone else.
-  /// \param debug [in] If true, read in binary mode.
+  /// \param binary [in] If true, read in binary mode.
   static Teuchos::RCP<const map_type>
   readMap(std::istream& in,
           const trcp_tcomm_t& comm,
@@ -5133,7 +5133,7 @@ class Reader {
   ///   from the file.
   /// \param debug [in] If true, write copious debugging output to
   ///   \c err on all processes in \c comm.
-  /// \param debug [in] If true, read in binary mode.
+  /// \param binary [in] If true, read in binary mode.
   static Teuchos::RCP<const map_type>
   readMap(std::istream& in,
           const trcp_tcomm_t& comm,
@@ -5517,7 +5517,7 @@ class Reader {
   //! the number of ranks hammering on the file system at once, but we don't
   //! make any guarantees.
   /// \param filename_prefix  [in] File for rank I is filename_prefix + to_string(I) + filename_suffix
-  /// \param filename_sufffix [in] File for rank I is filename_prefix + to_string(I) + filename_suffix
+  /// \param filename_suffix [in] File for rank I is filename_prefix + to_string(I) + filename_suffix
   /// \param rowMap [in] The Map over which to distribute rows
   ///   of the sparse matrix.  This must be nonnull.
   /// \param colMap [in/out] If nonnull: the Map over which to
@@ -5536,6 +5536,7 @@ class Reader {
   ///   matrix after reading it from a file.)
   /// \param tolerant [in] Whether to read the data tolerantly
   ///   from the file.
+  /// \param ranksToReadAtOnce [in] Number of ranks to read at once.
   /// \param debug [in] Whether to produce copious status output
   ///   useful for Tpetra developers, but probably not useful for
   ///   anyone else.

packages/tpetra/core/inout/Tpetra_Details_CooMatrix.hpp

@@ -108,9 +108,9 @@ class CooMatrixImpl {
   ///
   /// This works like multiple calls to sumIntoGlobalValue.
   ///
-  /// \param gblRowInd [in] Global row indices of the entries to insert.
-  /// \param gblColInd [in] Global column indices of the entries to insert.
-  /// \param val [in] Values of the matrix entries to insert / sum.
+  /// \param gblRowInds [in] Global row indices of the entries to insert.
+  /// \param gblColInds [in] Global column indices of the entries to insert.
+  /// \param vals [in] Values of the matrix entries to insert / sum.
   /// \param numEnt [in] Number of entries to insert.
   void
   sumIntoGlobalValues(const GO gblRowInds[],
@@ -210,6 +210,7 @@ class CooMatrixImpl {
   ///   needed for the row.  Must be an int for MPI's sake.
   /// \param gblRow [in] Global index of the row to pack.
   /// \param comm [in] Communicator for packing.
+  /// \param errStrm [out] Optional output stream for error messages.
   ///
   /// \return Error code; MPI_SUCESSS (0) if no error.
   int countPackRow(int& numPackets,
@@ -589,9 +590,9 @@ class CooMatrix : public ::Tpetra::DistObject<char, LO, GO, NT> {
   ///
   /// This works like multiple calls to sumIntoGlobalValue.
   ///
-  /// \param gblRowInd [in] Global row indices of the entries to insert.
-  /// \param gblColInd [in] Global column indices of the entries to insert.
-  /// \param val [in] Values of the matrix entries to insert / sum.
+  /// \param gblRowInds [in] Global row indices of the entries to insert.
+  /// \param gblColInds [in] Global column indices of the entries to insert.
+  /// \param vals [in] Values of the matrix entries to insert / sum.
   /// \param numEnt [in] Number of entries to insert.
   void
   sumIntoGlobalValues(const GO gblRowInds[],

packages/tpetra/core/inout/Tpetra_Details_ReadTriples.hpp

@@ -508,6 +508,7 @@ int readTriples(std::istream& inputStream,
 /// \param tolerant [in] Whether to read tolerantly.
 /// \param errStrm [in] If not NULL, print any error messages to this
 ///   stream.
+/// \param debug [in] If true, print debug messages.
 template <class SC, class GO>
 int readAndSendOneBatchOfTriples(std::istream& inputStream,
                                  std::size_t& curLineNum,
@@ -751,6 +752,7 @@ int readAndSendOneBatchOfTriples(std::istream& inputStream,
 /// \param tolerant [in] Whether to read tolerantly.
 /// \param errStrm [in] If not NULL, print any error messages to this
 ///   stream.
+/// \param debug [in] If true, print debug messages.
 template <class SC, class GO, class CommRequestPtr>
 int recvOneBatchOfTriples(std::vector<GO>& rowInds,
                           std::vector<GO>& colInds,
@@ -870,10 +872,12 @@ int recvOneBatchOfTriples(std::vector<GO>& rowInds,
 ///   is an error code, that is zero if and only if the closure
 ///   succeeded.  We intend for you to use this to call
 ///   CooMatrix::insertEntry.
+/// \param maxNumEntPerMsg [in] Maximum number of entries per message.
 /// \param comm [in] Communicator to use for receiving the triples.
 /// \param tolerant [in] Whether to read tolerantly.
 /// \param errStrm [in] If not NULL, print any error messages to this
 ///   stream.
+/// \param debug [in] Whether to print debug output.
 ///
 /// \return Error code; 0 if and only if success.
 template <class SC, class GO>

packages/tpetra/core/src/Tpetra_ApplyOp.hpp

@@ -83,6 +83,12 @@ class ApplyOp : public Tpetra::Operator<Scalar,
   /// \brief Compute <tt>Y = beta*Y + alpha*Op(A)*X</tt>, where
   ///   <tt>Op(A)</tt> is either A, \f$A^T\f$, or \f$A^H\f$.
   ///
+  /// \param X [in] Input MultiVector.
+  /// \param Y [in/out] Output MultiVector.
+  /// \param mode [in] Whether to apply the transpose (Teuchos::NO_TRANS, Teuchos::TRANS, Teuchos::CONJ_TRANS).
+  /// \param alpha [in] Scaling factor for the result.
+  /// \param beta [in] Scaling factor for Y before adding the result.
+  ///
   /// This method calls the underlying Operator object's
   /// applyTempl<Scalar,Scalar>() method.
   void

packages/tpetra/core/src/Tpetra_BlockCrsMatrix_decl.hpp

@@ -331,6 +331,13 @@ class BlockCrsMatrix : virtual public ::Tpetra::RowMatrix<Scalar, LO, GO, Node>,
 
   /// \brief For this matrix A, compute <tt>Y := beta * Y + alpha * Op(A) * X</tt>.
   ///
+  /// \param X [in] Input MultiVector.
+  /// \param Y [in/out] Output MultiVector.
+  /// \param mode [in] Whether to apply the transpose (Teuchos::NO_TRANS,
+  ///   Teuchos::TRANS, Teuchos::CONJ_TRANS).
+  /// \param alpha [in] Scaling factor for the result.
+  /// \param beta [in] Scaling factor for Y before adding the result.
+  ///
   /// Op(A) is A if mode is Teuchos::NO_TRANS, the transpose of A if
   /// mode is Teuchos::TRANS, and the conjugate transpose of A if mode
   /// is Teuchos::CONJ_TRANS.
@@ -404,6 +411,13 @@ class BlockCrsMatrix : virtual public ::Tpetra::RowMatrix<Scalar, LO, GO, Node>,
 
   /// \brief Version of apply() that takes BlockMultiVector input and output.
   ///
+  /// \param X [in] Input MultiVector.
+  /// \param Y [in/out] Output MultiVector.
+  /// \param mode [in] Whether to apply the transpose (Teuchos::NO_TRANS,
+  ///   Teuchos::TRANS, Teuchos::CONJ_TRANS).
+  /// \param alpha [in] Scaling factor for the result.
+  /// \param beta [in] Scaling factor for Y before adding the result.
+  ///
   /// This method is deliberately not marked const, because it may do
   /// lazy initialization of temporary internal block multivectors.
   void
@@ -498,27 +512,18 @@ class BlockCrsMatrix : virtual public ::Tpetra::RowMatrix<Scalar, LO, GO, Node>,
   /// indices directly, since the column indices are not stored as
   /// global indices in the graph.
   ///
-  /// \param localRowInd [in] Local (mesh, i.e., block) row index.
+  /// \param LocalRow [in] Local (mesh, i.e., block) row index.
   ///
-  /// \param colInds [out] If \c localRowInd is valid on the calling
+  /// \param indices [out] If \c LocalRow is valid on the calling
   ///   process, then on output, this is a pointer to the local (mesh,
   ///   i.e., block) column indices in the given (mesh, i.e., block)
-  ///   row.  If localRowInd is <i>not</i> valid, then this is
+  ///   row.  If LocalRow is <i>not</i> valid, then this is
   ///   undefined.  (Please check the return value of this method.)
   ///
-  /// \param vals [out] If \c localRowInd is valid on the calling
+  /// \param values [out] If \c LocalRow is valid on the calling
   ///   process, then on output, this is a pointer to the row's
-  ///   values.  If localRowInd is <i>not</i> valid, then this is
+  ///   values.  If LocalRow is <i>not</i> valid, then this is
   ///   undefined.  (Please check the return value of this method.)
-  ///
-  /// \param numInds [in] The number of (mesh, i.e., block) indices in
-  ///   \c colInds on output.
-  ///
-  /// \return 0 if \c localRowInd is valid, else
-  ///   <tt>Teuchos::OrdinalTraits<LO>::invalid()</tt>.
-  /// KK: this is inherited from row matrix interface and it returns const
-  ///      this cannot replace the deprecated pointer interface
-  ///      we need nonconst version of this code
   void
   getLocalRowView(LO LocalRow,
                   local_inds_host_view_type& indices,
@@ -718,6 +723,10 @@ class BlockCrsMatrix : virtual public ::Tpetra::RowMatrix<Scalar, LO, GO, Node>,
   /// diagonal of the matrix.
  protected:
   //! Like sumIntoLocalValues, but for the ABSMAX combine mode.
+  /// \param localRowInd [in] Local row index.
+  /// \param colInds [in] Array of local column indices.
+  /// \param vals [in] Array of values to ABSMAX into the matrix.
+  /// \param numColInds [in] Number of column indices.
   LO absMaxLocalValues(const LO localRowInd,
                        const LO colInds[],
                        const Scalar vals[],
@@ -968,6 +977,13 @@ class BlockCrsMatrix : virtual public ::Tpetra::RowMatrix<Scalar, LO, GO, Node>,
   /// \brief Global sparse matrix-vector multiply for the transpose or
   ///   conjugate transpose cases.
   ///
+  /// \param X [in] Input MultiVector.
+  /// \param Y [in/out] Output MultiVector.
+  /// \param mode [in] Whether to apply the transpose (Teuchos::TRANS,
+  ///   or Teuchos::CONJ_TRANS).
+  /// \param alpha [in] Scaling factor for the result.
+  /// \param beta [in] Scaling factor for Y before adding the result.
+  ///
   /// This method computes Y := beta*Y + alpha*Op(A)*X, where A is
   /// *this (the block matrix), Op(A) signifies either the transpose
   /// or the conjugate transpose of A, and X and Y are block

packages/tpetra/core/src/Tpetra_CrsGraph_decl.hpp

@@ -521,6 +521,13 @@ class CrsGraph : public RowGraph<LocalOrdinal, GlobalOrdinal, Node>,
   /// \param lclGraph [in] The local graph.  In almost all cases the
   ///   local graph must be sorted on input,
   ///   but if it isn't sorted, "sorted" must be set to false in params.
+  /// \param rowMap [in] Row map.
+  /// \param colMap [in] Column map.
+  /// \param domainMap [in] Domain map.
+  /// \param rangeMap [in] Range map.
+  /// \param importer [in] Import.
+  /// \param exporter [in] Export.
+  /// \param params [in/out] Optional list of parameters.
   CrsGraph(const local_graph_device_type& lclGraph,
            const Teuchos::RCP<const map_type>& rowMap,
            const Teuchos::RCP<const map_type>& colMap,