void
BAffineTransform::ApplyInverse(BPoint* points, uint32 count) const
{
if (points != NULL) {
for (uint32 i = 0; i < count; ++i)
ApplyInverse(&points[i]);
}
}
BPoint
BAffineTransform::ApplyInverse(const BPoint& point) const
{
double x = point.x;
double y = point.y;
ApplyInverse(&x, &y);
return BPoint(x, y);
}
void
BAffineTransform::ApplyInverse(BPoint* point) const
{
if (point == NULL)
return;
double x = point->x;
double y = point->y;
ApplyInverse(&x, &y);
point->x = x;
point->y = y;
}
// ================================================ ====== ==== ==== == =
// the tentative null space is in input because the user
// has to remember to allocate and fill it, and then to delete
// it after calling this method.
int ML_Epetra::MultiLevelPreconditioner::
ComputeAdaptivePreconditioner(int TentativeNullSpaceSize,
double* TentativeNullSpace)
{
if ((TentativeNullSpaceSize == 0) || (TentativeNullSpace == 0))
ML_CHK_ERR(-1);
// ================================== //
// get parameters from the input list //
// ================================== //
// maximum number of relaxation sweeps
int MaxSweeps = List_.get("adaptive: max sweeps", 10);
// number of std::vector to be added to the tentative null space
int NumAdaptiveVectors = List_.get("adaptive: num vectors", 1);
if (verbose_) {
std::cout << PrintMsg_ << "*** Adaptive Smoother Aggregation setup ***" << std::endl;
std::cout << PrintMsg_ << " Maximum relaxation sweeps = " << MaxSweeps << std::endl;
std::cout << PrintMsg_ << " Additional vectors to compute = " << NumAdaptiveVectors << std::endl;
}
// ==================================================== //
// compute the preconditioner, set null space from user //
// (who will have to delete std::vector TentativeNullSpace) //
// ==================================================== //
double* NewNullSpace = 0;
double* OldNullSpace = TentativeNullSpace;
int OldNullSpaceSize = TentativeNullSpaceSize;
// need some work otherwise matvec() with Epetra_Vbr fails.
// Also, don't differentiate between range and domain here
// as ML will not work if range != domain
const Epetra_VbrMatrix* VbrA = NULL;
VbrA = dynamic_cast<const Epetra_VbrMatrix*>(RowMatrix_);
Epetra_Vector* LHS = 0;
Epetra_Vector* RHS = 0;
if (VbrA != 0) {
LHS = new Epetra_Vector(VbrA->DomainMap());
RHS = new Epetra_Vector(VbrA->DomainMap());
} else {
LHS = new Epetra_Vector(RowMatrix_->OperatorDomainMap());
RHS = new Epetra_Vector(RowMatrix_->OperatorDomainMap());
}
// destroy what we may already have
if (IsComputePreconditionerOK_ == true) {
DestroyPreconditioner();
}
// build the preconditioner for the first time
List_.set("null space: type", "pre-computed");
List_.set("null space: dimension", OldNullSpaceSize);
List_.set("null space: vectors", OldNullSpace);
ComputePreconditioner();
// ====================== //
// add one std::vector at time //
// ====================== //
for (int istep = 0 ; istep < NumAdaptiveVectors ; ++istep) {
if (verbose_) {
std::cout << PrintMsg_ << "\tAdaptation step " << istep << std::endl;
std::cout << PrintMsg_ << "\t---------------" << std::endl;
}
// ==================== //
// look for "bad" modes //
// ==================== //
// note: should an error occur, ML_CHK_ERR will return,
// and LHS and RHS will *not* be delete'd (--> memory leak).
// Anyway, this means that something wrong happened in the code
// and should be fixed by the user.
LHS->Random();
double Norm2;
for (int i = 0 ; i < MaxSweeps ; ++i) {
// RHS = (I - ML^{-1} A) LHS
ML_CHK_ERR(RowMatrix_->Multiply(false,*LHS,*RHS));
// FIXME: can do something slightly better here
ML_CHK_ERR(ApplyInverse(*RHS,*RHS));
ML_CHK_ERR(LHS->Update(-1.0,*RHS,1.0));
LHS->Norm2(&Norm2);
if (verbose_) {
std::cout << PrintMsg_ << "\titer " << i << ", ||x||_2 = ";
std::cout << Norm2 << std::endl;
}
}
// scaling vectors
double NormInf;
LHS->NormInf(&NormInf);
LHS->Scale(1.0 / NormInf);
// ========================================================= //
// copy tentative and computed null space into NewNullSpace, //
// which now becomes the standard null space //
// ========================================================= //
int NewNullSpaceSize = OldNullSpaceSize + 1;
NewNullSpace = new double[NumMyRows() * NewNullSpaceSize];
assert (NewNullSpace != 0);
int itmp = OldNullSpaceSize * NumMyRows();
for (int i = 0 ; i < itmp ; ++i) {
NewNullSpace[i] = OldNullSpace[i];
}
for (int j = 0 ; j < NumMyRows() ; ++j) {
NewNullSpace[itmp + j] = (*LHS)[j];
}
// =============== //
// visualize modes //
// =============== //
if (List_.get("adaptive: visualize", false)) {
double* x_coord = List_.get("viz: x-coordinates", (double*)0);
double* y_coord = List_.get("viz: y-coordinates", (double*)0);
double* z_coord = List_.get("viz: z-coordinates", (double*)0);
assert (x_coord != 0);
std::vector<double> plot_me(NumMyRows()/NumPDEEqns_);
ML_Aggregate_Viz_Stats info;
info.Amatrix = &(ml_->Amat[LevelID_[0]]);
info.x = x_coord;
info.y = y_coord;
info.z = z_coord;
info.Nlocal = NumMyRows() / NumPDEEqns_;
info.Naggregates = 1;
ML_Operator_AmalgamateAndDropWeak(&(ml_->Amat[LevelID_[0]]),
NumPDEEqns_, 0.0);
for (int ieqn = 0 ; ieqn < NumPDEEqns_ ; ++ieqn) {
for (int j = 0 ; j < NumMyRows() ; j+=NumPDEEqns_) {
plot_me[j / NumPDEEqns_] = (*LHS)[j + ieqn];
}
char FileName[80];
sprintf(FileName,"nullspace-mode%d-eq%d.xyz", istep, ieqn);
if (verbose_)
std::cout << PrintMsg_ << "writing file " << FileName << "..." << std::endl;
ML_Aggregate_VisualizeXYZ(info,FileName,
ml_->comm,&plot_me[0]);
}
ML_Operator_UnAmalgamateAndDropWeak(&(ml_->Amat[LevelID_[0]]),
NumPDEEqns_, 0.0);
}
// Destroy the old preconditioner
DestroyPreconditioner();
// ==================================================== //
// build the new preconditioner with the new null space //
// ==================================================== //
List_.set("null space: type", "pre-computed");
List_.set("null space: dimension", NewNullSpaceSize);
List_.set("null space: vectors", NewNullSpace);
ML_CHK_ERR(ComputePreconditioner());
if (istep && (istep != NumAdaptiveVectors))
delete OldNullSpace;
OldNullSpace = NewNullSpace;
OldNullSpaceSize = NewNullSpaceSize;
}
// keep trace of this pointer, it will be delete'd later
NullSpaceToFree_ = NewNullSpace;
delete LHS;
delete RHS;
return(0);
}
inline int applyInverse (const VectorEpetra& X, VectorEpetra& Y)
{
return ApplyInverse (X.epetraVector(), Y.epetraVector() );
}
