/// <summary>
/// Ganz ok.
/// </summary>
ISolverSmootherTemplate MultilevelSchwarz(MultigridOperator op) {
var solver = new SoftPCG() {
m_MaxIterations = 500,
m_Tolerance = 1.0e-12
};
//var solver = new OrthonormalizationScheme() {
// MaxIter = 500,
// Tolerance = 1.0e-10,
//};
//var solver = new SoftGMRES() {
// m_MaxIterations = 500,
// m_Tolerance = 1.0e-10,
//};
// my tests show that the ideal block size may be around 10'000
int DirectKickIn = base.Control.TargetBlockSize;
MultigridOperator Current = op;
ISolverSmootherTemplate[] MultigridChain = new ISolverSmootherTemplate[base.MultigridSequence.Length];
for (int iLevel = 0; iLevel < base.MultigridSequence.Length; iLevel++) {
int SysSize = Current.Mapping.TotalLength;
int NoOfBlocks = (int)Math.Ceiling(((double)SysSize) / ((double)DirectKickIn));
bool useDirect = false;
useDirect |= (SysSize < DirectKickIn);
useDirect |= iLevel == base.MultigridSequence.Length - 1;
useDirect |= NoOfBlocks.MPISum() <= 1;
if (useDirect) {
MultigridChain[iLevel] = new DirectSolver() {
WhichSolver = DirectSolver._whichSolver.PARDISO,
TestSolution = false
};
} else {
ClassicMultigrid MgLevel = new ClassicMultigrid() {
m_MaxIterations = 1,
m_Tolerance = 0.0 // termination controlled by top level PCG
};
MultigridChain[iLevel] = MgLevel;
ISolverSmootherTemplate pre, pst;
if (iLevel > 0) {
Schwarz swz1 = new Schwarz() {
m_MaxIterations = 1,
CoarseSolver = null,
m_BlockingStrategy = new Schwarz.METISBlockingStrategy() {
NoOfPartsPerProcess = NoOfBlocks
},
Overlap = 0 // overlap does **NOT** seem to help
};
SoftPCG pcg1 = new SoftPCG() {
m_MinIterations = 5,
m_MaxIterations = 5
};
SoftPCG pcg2 = new SoftPCG() {
m_MinIterations = 5,
m_MaxIterations = 5
};
var preChain = new ISolverSmootherTemplate[] { swz1, pcg1 };
var pstChain = new ISolverSmootherTemplate[] { swz1, pcg2 };
pre = new SolverSquence() { SolverChain = preChain };
pst = new SolverSquence() { SolverChain = pstChain };
} else {
// +++++++++++++++++++++++++++++++++++++++++++++++++++
// top level - use only iterative (non-direct) solvers
// +++++++++++++++++++++++++++++++++++++++++++++++++++
pre = new BlockJacobi() {
NoOfIterations = 3,
omega = 0.5
};
pst = new BlockJacobi() {
NoOfIterations = 3,
omega = 0.5
};
//preChain = new ISolverSmootherTemplate[] { pcg1 };
//pstChain = new ISolverSmootherTemplate[] { pcg2 };
}
//if (iLevel > 0) {
// MgLevel.PreSmoother = pre;
// MgLevel.PostSmoother = pst;
//} else {
// //MgLevel.PreSmoother = pcg1; // ganz schlechte Idee, konvergiert gegen FALSCHE lösung
// //MgLevel.PostSmoother = pcg2; // ganz schlechte Idee, konvergiert gegen FALSCHE lösung
// MgLevel.PreSmoother = pre;
// MgLevel.PostSmoother = pst;
//}
MgLevel.PreSmoother = pre;
MgLevel.PostSmoother = pst;
}
if (iLevel > 0) {
((ClassicMultigrid)(MultigridChain[iLevel - 1])).CoarserLevelSolver = MultigridChain[iLevel];
}
if (useDirect) {
Console.WriteLine("MG: using {0} levels, lowest level DOF is {1}, target size is {2}.", iLevel + 1, SysSize, DirectKickIn);
break;
}
Current = Current.CoarserLevel;
} // end of level loop
solver.Precond = MultigridChain[0];
//solver.PrecondS = new[] { MultigridChain[0] };
return solver;
}
/// <summary>
///
/// </summary>
ISolverSmootherTemplate KcycleMultiSchwarz(MultigridOperator op) {
var solver = new OrthonormalizationScheme() {
MaxIter = 500,
Tolerance = 1.0e-10,
};
// my tests show that the ideal block size may be around 10'000
int DirectKickIn = base.Control.TargetBlockSize;
MultigridOperator Current = op;
var PrecondChain = new List<ISolverSmootherTemplate>();
for (int iLevel = 0; iLevel < base.MultigridSequence.Length; iLevel++) {
int SysSize = Current.Mapping.TotalLength;
int NoOfBlocks = (int)Math.Ceiling(((double)SysSize) / ((double)DirectKickIn));
bool useDirect = false;
useDirect |= (SysSize < DirectKickIn);
useDirect |= iLevel == base.MultigridSequence.Length - 1;
useDirect |= NoOfBlocks.MPISum() <= 1;
ISolverSmootherTemplate levelSolver;
if (useDirect) {
levelSolver = new DirectSolver() {
WhichSolver = DirectSolver._whichSolver.PARDISO,
TestSolution = false
};
} else {
Schwarz swz1 = new Schwarz() {
m_MaxIterations = 1,
CoarseSolver = null,
m_BlockingStrategy = new Schwarz.METISBlockingStrategy() {
NoOfPartsPerProcess = NoOfBlocks
},
Overlap = 2 // overlap seems to help
};
SoftPCG pcg1 = new SoftPCG() {
m_MinIterations = 5,
m_MaxIterations = 5
};
//*/
var pre = new SolverSquence() {
SolverChain = new ISolverSmootherTemplate[] { swz1, pcg1 }
};
levelSolver = swz1;
}
if (iLevel > 0) {
GenericRestriction[] R = new GenericRestriction[iLevel];
for (int ir = 0; ir < R.Length; ir++) {
R[ir] = new GenericRestriction();
if (ir >= 1)
R[ir - 1].CoarserLevelSolver = R[ir];
}
R[iLevel - 1].CoarserLevelSolver = levelSolver;
PrecondChain.Add(R[0]);
} else {
PrecondChain.Add(levelSolver);
}
if (useDirect) {
Console.WriteLine("Kswz: using {0} levels, lowest level DOF is {1}, target size is {2}.", iLevel + 1, SysSize, DirectKickIn);
break;
}
Current = Current.CoarserLevel;
}
if (PrecondChain.Count > 1) {
/*
// construct a V-cycle
for (int i = PrecondChain.Count - 2; i>= 0; i--) {
PrecondChain.Add(PrecondChain[i]);
}
*/
var tmp = PrecondChain.ToArray();
for (int i = 0; i < PrecondChain.Count; i++) {
PrecondChain[i] = tmp[PrecondChain.Count - 1 - i];
}
}
solver.PrecondS = PrecondChain.ToArray();
solver.MaxKrylovDim = solver.PrecondS.Length * 4;
return solver;
}
