void BlockedRAPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node>::Build(Level &fineLevel, Level &coarseLevel) const { //FIXME make fineLevel const!!
FactoryMonitor m(*this, "Computing Ac (block)", coarseLevel);
const Teuchos::ParameterList& pL = GetParameterList();
RCP<Matrix> A = Get< RCP<Matrix> >(fineLevel, "A");
RCP<Matrix> P = Get< RCP<Matrix> >(coarseLevel, "P");
RCP<BlockedCrsMatrix> bA = rcp_dynamic_cast<BlockedCrsMatrix>(A);
RCP<BlockedCrsMatrix> bP = rcp_dynamic_cast<BlockedCrsMatrix>(P);
TEUCHOS_TEST_FOR_EXCEPTION(bA.is_null() || bP.is_null(), Exceptions::BadCast, "Matrices R, A and P must be of type BlockedCrsMatrix.");
RCP<BlockedCrsMatrix> bAP;
RCP<BlockedCrsMatrix> bAc;
{
SubFactoryMonitor subM(*this, "MxM: A x P", coarseLevel);
// Triple matrix product for BlockedCrsMatrixClass
TEUCHOS_TEST_FOR_EXCEPTION((bA->Cols() != bP->Rows()), Exceptions::BadCast,
"Block matrix dimensions do not match: "
"A is " << bA->Rows() << "x" << bA->Cols() <<
"P is " << bP->Rows() << "x" << bP->Cols());
bAP = Utils::TwoMatrixMultiplyBlock(*bA, false, *bP, false, GetOStream(Statistics2), true, true);
}
// If we do not modify matrix later, allow optimization of storage.
// This is necessary for new faster Epetra MM kernels.
bool doOptimizeStorage = !checkAc_;
const bool doTranspose = true;
const bool doFillComplete = true;
if (pL.get<bool>("transpose: use implicit") == true) {
SubFactoryMonitor m2(*this, "MxM: P' x (AP) (implicit)", coarseLevel);
bAc = Utils::TwoMatrixMultiplyBlock(*bP, doTranspose, *bAP, !doTranspose, GetOStream(Statistics2), doFillComplete, doOptimizeStorage);
} else {
RCP<Matrix> R = Get< RCP<Matrix> >(coarseLevel, "R");
RCP<BlockedCrsMatrix> bR = rcp_dynamic_cast<BlockedCrsMatrix>(R);
TEUCHOS_TEST_FOR_EXCEPTION(bR.is_null(), Exceptions::BadCast, "Matrix R must be of type BlockedCrsMatrix.");
TEUCHOS_TEST_FOR_EXCEPTION(bA->Rows() != bR->Cols(), Exceptions::BadCast,
"Block matrix dimensions do not match: "
"R is " << bR->Rows() << "x" << bR->Cols() <<
"A is " << bA->Rows() << "x" << bA->Cols());
SubFactoryMonitor m2(*this, "MxM: R x (AP) (explicit)", coarseLevel);
bAc = Utils::TwoMatrixMultiplyBlock(*bR, !doTranspose, *bAP, !doTranspose, GetOStream(Statistics2), doFillComplete, doOptimizeStorage);
}
if (checkAc_)
CheckMainDiagonal(bAc);
GetOStream(Statistics1) << PerfUtils::PrintMatrixInfo(*bAc, "Ac (blocked)");
// static int run = 1;
// RCP<CrsMatrixWrap> A11 = rcp(new CrsMatrixWrap(bAc->getMatrix(0,0)));
// Utils::Write(toString(run) + "_A_11.mm", *A11);
// if (!bAc->getMatrix(1,1).is_null()) {
// RCP<CrsMatrixWrap> A22 = rcp(new CrsMatrixWrap(bAc->getMatrix(1,1)));
// Utils::Write(toString(run) + "_A_22.mm", *A22);
// }
// RCP<CrsMatrixWrap> Am = rcp(new CrsMatrixWrap(bAc->Merge()));
// Utils::Write(toString(run) + "_A.mm", *Am);
// run++;
Set<RCP <Matrix> >(coarseLevel, "A", bAc);
if (transferFacts_.begin() != transferFacts_.end()) {
SubFactoryMonitor m1(*this, "Projections", coarseLevel);
// call Build of all user-given transfer factories
for (std::vector<RCP<const FactoryBase> >::const_iterator it = transferFacts_.begin(); it != transferFacts_.end(); ++it) {
RCP<const FactoryBase> fac = *it;
GetOStream(Runtime0) << "BlockRAPFactory: call transfer factory: " << fac->description() << std::endl;
fac->CallBuild(coarseLevel);
// AP (11/11/13): I am not sure exactly why we need to call Release, but we do need it to get rid
// of dangling data for CoordinatesTransferFactory
coarseLevel.Release(*fac);
}
}
}
void RAPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::Build(Level &fineLevel, Level &coarseLevel) const { // FIXME make fineLevel const
{
FactoryMonitor m(*this, "Computing Ac", coarseLevel);
// Set "Keeps" from params
const Teuchos::ParameterList& pL = GetParameterList();
if (pL.isParameter("Keep AP Pattern") && pL.get<bool>("Keep AP Pattern"))
coarseLevel.Keep("AP Pattern", this);
if (pL.isParameter("Keep RAP Pattern") && pL.get<bool>("Keep RAP Pattern"))
coarseLevel.Keep("RAP Pattern", this);
//
// Inputs: A, P
//
RCP<Matrix> A = Get< RCP<Matrix> >(fineLevel, "A");
RCP<Matrix> P = Get< RCP<Matrix> >(coarseLevel, "P");
//
// Build Ac = RAP
//
RCP<Matrix> AP;
// Reuse pattern if available (multiple solve)
if (coarseLevel.IsAvailable("AP Pattern", this)){
GetOStream(Runtime0, 0) << "Ac: Using previous AP pattern"<<std::endl;
AP = Get< RCP<Matrix> >(coarseLevel, "AP Pattern");
}
{
SubFactoryMonitor subM(*this, "MxM: A x P", coarseLevel);
AP = Utils::Multiply(*A, false, *P, false, AP);
Set(coarseLevel, "AP Pattern", AP);
}
bool doOptimizedStorage = !checkAc_; // Optimization storage option. If not modifying matrix later (inserting local values), allow optimization of storage.
// This is necessary for new faster Epetra MM kernels.
RCP<Matrix> Ac;
// Reuse coarse matrix memory if available (multiple solve)
if (coarseLevel.IsAvailable("RAP Pattern", this)) {
GetOStream(Runtime0, 0) << "Ac: Using previous RAP pattern" << std::endl;
Ac = Get< RCP<Matrix> >(coarseLevel, "RAP Pattern");
}
if (implicitTranspose_) {
SubFactoryMonitor m2(*this, "MxM: P' x (AP) (implicit)", coarseLevel);
Ac = Utils::Multiply(*P, true, *AP, false, Ac, true, doOptimizedStorage);
} else {
SubFactoryMonitor m2(*this, "MxM: R x (AP) (explicit)", coarseLevel);
RCP<Matrix> R = Get< RCP<Matrix> >(coarseLevel, "R");
Ac = Utils::Multiply(*R, false, *AP, false, Ac, true, doOptimizedStorage);
}
if (checkAc_)
CheckMainDiagonal(Ac);
RCP<ParameterList> params = rcp(new ParameterList());;
params->set("printLoadBalancingInfo", true);
GetOStream(Statistics0, 0) << Utils::PrintMatrixInfo(*Ac, "Ac", params);
Set(coarseLevel, "A", Ac);
Set(coarseLevel, "RAP Pattern", Ac);
}
if (transferFacts_.begin() != transferFacts_.end()) {
SubFactoryMonitor m(*this, "Projections", coarseLevel);
// call Build of all user-given transfer factories
for (std::vector<RCP<const FactoryBase> >::const_iterator it = transferFacts_.begin(); it != transferFacts_.end(); ++it) {
GetOStream(Runtime0, 0) << "Ac: call transfer factory " << (*it).get() << ": " << (*it)->description() << std::endl;
(*it)->CallBuild(coarseLevel);
}
}
}
void BlockedRAPFactory<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps>::Build(Level &fineLevel, Level &coarseLevel) const { //FIXME make fineLevel const!!
typedef Xpetra::BlockedCrsMatrix<Scalar, LocalOrdinal, GlobalOrdinal, Node, LocalMatOps> BlockedCrsMatrixClass; // TODO move me
FactoryMonitor m(*this, "Computing Ac (block)", coarseLevel);
//
// Inputs: R, A, P
//
RCP<Matrix> R = Get< RCP<Matrix> >(coarseLevel, "R");
RCP<Matrix> A = Get< RCP<Matrix> >(fineLevel, "A");
RCP<Matrix> P = Get< RCP<Matrix> >(coarseLevel, "P");
//
// Dynamic casts
//
RCP<BlockedCrsMatrixClass> bR, bA, bP;
try {
/* using rcp_dynamic_cast with throw_on_fail = true */
bR = Teuchos::rcp_dynamic_cast<BlockedCrsMatrixClass>(R, true);
bA = Teuchos::rcp_dynamic_cast<BlockedCrsMatrixClass>(A, true);
bP = Teuchos::rcp_dynamic_cast<BlockedCrsMatrixClass>(P, true);
} catch(std::bad_cast e) {
TEUCHOS_TEST_FOR_EXCEPTION(true, Exceptions::BadCast, "MueLu::BlockedRAPFactory::Build(): matrices R, A and P must be of type BlockedCrsMatrix. " << e.what());
}
/*Utils::Write( "A00.m", CrsMatrixWrap(bA->getMatrix(0,0)) );
Utils::Write( "A11.m", CrsMatrixWrap(bA->getMatrix(1,1)) );
Utils::Write( "A01.m", CrsMatrixWrap(bA->getMatrix(0,1)) );
Utils::Write( "A10.m", CrsMatrixWrap(bA->getMatrix(1,0)) );
Utils::Write( "P00.m", CrsMatrixWrap(bP->getMatrix(0,0)) );
Utils::Write( "P11.m", CrsMatrixWrap(bP->getMatrix(1,1)) );*/
//
// Build Ac = RAP
//
// Triple matrix product for BlockedCrsMatrixClass
TEUCHOS_TEST_FOR_EXCEPTION((bA->Cols() != bP->Rows()) || (bA->Rows() != bR->Cols()), Exceptions::BadCast, "MueLu::BlockedRAPFactory::Build(): block matrix dimensions do not match.");
RCP<BlockedCrsMatrixClass> bAP = Utils::TwoMatrixMultiplyBlock(*bA, false, *bP, false, true, true);
RCP<BlockedCrsMatrixClass> bAc = Utils::TwoMatrixMultiplyBlock(*bR, false, *bAP, false, true, true);
if (checkAc_)
CheckMainDiagonal(bAc);
GetOStream(Statistics1, 0) << Utils::PrintMatrixInfo(*bAc, "Ac (blocked)");
Set<RCP <Matrix> >(coarseLevel, "A", bAc);
if (transferFacts_.begin() != transferFacts_.end()) {
SubFactoryMonitor m1(*this, "Projections", coarseLevel);
// call Build of all user-given transfer factories
for (std::vector<RCP<const FactoryBase> >::const_iterator it = transferFacts_.begin(); it != transferFacts_.end(); ++it) {
RCP<const FactoryBase> fac = *it;
GetOStream(Runtime0, 0) << "BlockRAPFactory: call transfer factory: " << fac->description() << std::endl;
fac->CallBuild(coarseLevel);
// AP (11/11/13): I am not sure exactly why we need to call Release, but we do need it to get rid
// of dangling data for CoordinatesTransferFactory
coarseLevel.Release(*fac);
}
}
}
