public static void TestLinearSolverConfigurations()
{
//Arrange --- configs
var ACS = new AppControlSolver();
LinearSolverConfig lconfig = ACS.LinearSolver;
NonLinearSolverConfig nlconfig = ACS.NonLinearSolver; // is not of interest in this test, but we have to set this ...
lconfig.verbose = true;
lconfig.NoOfMultigridLevels = 3;
lconfig.TargetBlockSize = 10;
var SF = new SolverFactory(nlconfig, lconfig);
//Arrange --- Multigrid stuff
AggregationGridData[] seq;
var MGO = Utils.CreateTestMGOperator(out seq, Resolution: 10);
var changeofbasisis = Utils.GetAllMGConfig(MGO);
var agggridbasisis = Utils.GetAllAggGridBasis(MGO);
//Arrange --- get available lincodes
var lincodes = (LinearSolverCode[])Enum.GetValues(typeof(LinearSolverCode));
ISolverSmootherTemplate LinSolver = null;
TestDelegate lindlg = () => SF.GenerateLinear(out LinSolver, agggridbasisis, changeofbasisis);
//Act and Assert
foreach (LinearSolverCode code in lincodes)
{
SF.Clear();
lconfig.SolverCode = code;
if (code == LinearSolverCode.selfmade)
{
SF.Selfmade_linsolver = new DirectSolver()
{
WhichSolver = DirectSolver._whichSolver.PARDISO
}
}
;
Assert.DoesNotThrow(lindlg, "", null);
Assert.IsNotNull(LinSolver);
}
}
private void ExperimentalSolver(out double mintime, out double maxtime, out bool Converged, out int NoOfIter, out int DOFs)
{
using (var tr = new FuncTrace()) {
mintime = double.MaxValue;
maxtime = 0;
Converged = false;
NoOfIter = int.MaxValue;
DOFs = 0;
AggregationGridBasis[][] XAggB;
using (new BlockTrace("Aggregation_basis_init", tr)) {
XAggB = AggregationGridBasis.CreateSequence(base.MultigridSequence, u.Mapping.BasisS);
}
XAggB.UpdateXdgAggregationBasis(this.Op_Agglomeration);
var MassMatrix = this.Op_mass.GetMassMatrix(this.u.Mapping, new double[] { 1.0 }, false, this.LsTrk.SpeciesIdS.ToArray());
double[] _RHSvec = this.GetRHS();
Stopwatch stw = new Stopwatch();
stw.Reset();
stw.Start();
Console.WriteLine("Setting up multigrid operator...");
int p = this.u.Basis.Degree;
var MultigridOp = new MultigridOperator(XAggB, this.u.Mapping,
this.Op_Matrix,
this.Op_mass.GetMassMatrix(new UnsetteledCoordinateMapping(this.u.Basis), false),
OpConfig);
Assert.True(MultigridOp != null);
int L = MultigridOp.Mapping.LocalLength;
DOFs = MultigridOp.Mapping.TotalLength;
double[] RHSvec = new double[L];
MultigridOp.TransformRhsInto(_RHSvec, RHSvec);
ISolverSmootherTemplate exsolver;
SolverFactory SF = new SolverFactory(this.Control.NonLinearSolver, this.Control.LinearSolver);
List <Action <int, double[], double[], MultigridOperator> > Callbacks = new List <Action <int, double[], double[], MultigridOperator> >();
Callbacks.Add(CustomItCallback);
SF.GenerateLinear(out exsolver, MultigridSequence, OpConfig, Callbacks);
using (new BlockTrace("Solver_Init", tr)) {
exsolver.Init(MultigridOp);
}
/*
* string filename = "XdgPoisson" + this.Grid.SpatialDimension + "p" + this.u.Basis.Degree + "R" + this.Grid.CellPartitioning.TotalLength;
* MultigridOp.OperatorMatrix.SaveToTextFileSparse(filename + ".txt");
* RHSvec.SaveToTextFile(filename + "_rhs.txt");
*
* var uEx = this.u.CloneAs();
* Op_Agglomeration.ClearAgglomerated(uEx.Mapping);
* var CO = new ConvergenceObserver(MultigridOp, MassMatrix, uEx.CoordinateVector.ToArray());
* uEx = null;
* CO.TecplotOut = "PoissonConvergence";
* //CO.PlotDecomposition(this.u.CoordinateVector.ToArray());
*
* if (exsolver is ISolverWithCallback) {
* ((ISolverWithCallback)exsolver).IterationCallback = CO.IterationCallback;
* }
* //*/
XDGField u2 = u.CloneAs();
using (new BlockTrace("Solver_Run", tr)) {
// use solver (on XDG-field 'u2').
u2.Clear();
MultigridOp.UseSolver(exsolver, u2.CoordinateVector, _RHSvec);
Console.WriteLine("Solver: {0}, converged? {1}, {2} iterations.", exsolver.GetType().Name, exsolver.Converged, exsolver.ThisLevelIterations);
this.Op_Agglomeration.Extrapolate(u2.Mapping);
Assert.IsTrue(exsolver.Converged, "Iterative solver did not converge.");
}
stw.Stop();
mintime = Math.Min(stw.Elapsed.TotalSeconds, mintime);
maxtime = Math.Max(stw.Elapsed.TotalSeconds, maxtime);
Converged = exsolver.Converged;
NoOfIter = exsolver.ThisLevelIterations;
// compute error between reference solution and multigrid solver
XDGField ErrField = u2.CloneAs();
ErrField.Acc(-1.0, u);
double ERR = ErrField.L2Norm();
double RelERR = ERR / u.L2Norm();
Assert.LessOrEqual(RelERR, 1.0e-6, "Result from iterative solver above threshold.");
}
}