[Trilinos-Users] [EXTERNAL] Matrix-Matrix Multiplication (PtAP)

[Siefert, Christopher]

Alexander,

I'll take a look at that routine today or tomorrow.  Given recent developments in EpetraExt, that routine should be reimplemented anyway.

-Chris
________________________________________
From: Trilinos-Users <trilinos-users-bounces at trilinos.org> on behalf of Alexander Heinlein <aheinlei at uni-koeln.de>
Sent: Tuesday, April 28, 2015 8:36 AM
To: trilinos-users at trilinos.org
Subject: [EXTERNAL] [Trilinos-Users] Matrix-Matrix Multiplication (PtAP)

Dear Trilinos Users,

within my application I have to perform a matrix-matrix multiplication of P^tAP-type. Because, so far, I am mainly using the Epetra package,
I tried to to use the MatrixMatrix::Multiply method which is provided in the EpetraExt package. Soon, I realized that the multiplication
P^tA is getting extremely slow when the size of the matrices and the number of MPI-processes increase.

First I tried to replace the MatrixMatrix::Multiply method by the ML_Epetra::ML_Epetra_PtAP method, but this led to segmentation faults for
any size of the matrices. Thus I tried to build up a very simple example with the matrices P

   Processor    Row Index    Col Index           Value
       0             0             0                       1
       0             1             0                       1
       0             2             0                       1
       1             3             0                       1
       1             3             1                       1
       1             4             0                       1
       1             4             1                       1
       1             5             0                       1
       1             5             1                       1
       2             6             1                       1
       2             7             1                       1
       2             8             1                       1

and A

   Processor    Row Index    Col Index           Value
       0             0             0                       1
       0             0             1                       2
       0             1             0                       2
       0             1             1                       3
       0             1             2                       4
       0             2             1                       4
       0             2             2                       5
       0             2             3                       6
       1             3             2                       6
       1             3             3                       7
       1             3             4                       8
       1             4             3                       8
       1             4             4                       9
       1             4             5                      10
       1             5             4                      10
       1             5             5                      11
       1             5             6                      12
       2             6             5                      12
       2             6             6                      13
       2             6             7                      14
       2             7             6                      14
       2             7             7                      15
       2             7             8                      16
       2             8             7                      16
       2             8             8                      17.

For these matrices, again, using the multiplication of the EpetraExt package led to the correct result, while the method ML_Epetra::ML_Epetra_PtAP led to
segmentation faults. (When I use ML_Epetra::ML_Epetra_PtAP on just one process, it works.)

Additionally I tried to transpose the matrix P explicitly using ML_Operator_Transpose_byrow, and then to do the multiplication using the EpetraExt package.
Unfortunately, this yielded the wrong result.

Does anyone have experiences with this kind of multiplication? Do you have any suggestions how to implement this multiplication for arbitrary matrices in an
efficient way? Thank you a lot!

Best regards,
Alexander Heinlein
_______________________________________________
Trilinos-Users mailing list
Trilinos-Users at trilinos.org
https://trilinos.org/mailman/listinfo/trilinos-users