private void Helper1(IElementalAccessMatrix A, IElementalAccessVector b, IElementalAccessVector x)
{
// Test of usual solvers and preconditoners
ILinearSolver[] solver = new ILinearSolver[]
{
new BiCGSolver(),
new BiCGstabSolver(),
//new CGSolver(),
new CGSSolver(),
new GMRESSolver(),
new QMRSolver()
};
IPreconditioner[] M = new IPreconditioner[]
{
new IdentityPreconditioner(),
//new ILUPreconditioner(new SparseRowMatrix(A.RowCount, A.ColumnCount))
};
DefaultLinearIteration iter = new DefaultLinearIteration();
iter.SetParameters(1e-10, 1e-50, 1e+5, 1000000);
for (int i = 0; i < solver.Length; ++i)
{
for (int j = 0; j < M.Length; ++j)
{
Helper2(A, b, x, solver[i], M[j], iter);
}
}
}
public PoissonBase(IMatrixAssembler assembler, IBoundaryOperable boundary, ILinearSolver solverForMassMatrix, ILinearSolver solverForStiffnessMatrix)
{
_assembler = assembler;
_boundary = boundary;
_solverM = solverForMassMatrix;
_solverJ = solverForStiffnessMatrix;
}
private void Helper2(IElementalAccessMatrix A, IElementalAccessVector b,
IElementalAccessVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter)
{
Random r = new Random();
double K = r.NextDouble(), f = r.NextDouble(), gl = r.NextDouble(), gr = r.NextDouble();
//assemble(A, b, K, f);
//boundary(A, b, x, gl, gr);
A.SetValue(0, 0, 1);
A.SetValue(0, 1, 1);
A.SetValue(0, 2, 1.3);
A.SetValue(1, 0, -0.5);
A.SetValue(1, 1, -0.25);
A.SetValue(1, 2, -1.25);
A.SetValue(2, 0, 2.5);
A.SetValue(2, 1, 3.25);
A.SetValue(2, 2, -1.25);
b.SetValue(0, 1.25);
b.SetValue(1, 3.75);
b.SetValue(1, -2.35);
double[] ans = solve(A, b, x, solver, M, iter);
//double[] ref_Renamed = reference(b.Length - 1, K, f, gl, gr);
//checkEqual(ans, ref_Renamed);
Console.WriteLine("!: " + solver + " " + M + " " + iter + " " + x.GetValue(0) + " " + x.GetValue(1) + " " + x.GetValue(2));
Blas.Default.Zero(A);
Blas.Default.Zero(b);
Blas.Default.Zero(x);
}
private double[] solve(IMatrix A, IVector b, IVector x, ILinearSolver solver,
IPreconditioner M, ILinearIteration iter)
{
M.Setup(A);
solver.Preconditioner = M;
solver.Iteration = iter;
return(Blas.Default.GetArrayCopy(solver.Solve(A, b, x)));
}
Result <LoadIncrementalState> GetCorrection(LoadState state, LoadIncrementalState prediction, StructureInfo info)
{
ILinearSolver stiffnessMatrix = info.Stiffness(state.Displacement);
Vector <double> dut = stiffnessMatrix.Solve(info.ReferenceLoad);
Vector <double> reaction = info.Reaction(state.Displacement);
Vector <double> equilibrium = info.InitialLoad + state.Lambda * info.ReferenceLoad - reaction;
Vector <double> dur = stiffnessMatrix.Solve(equilibrium);
Result <LoadIncrementalState> incrementalStateResult = Scheme.Correct(state, prediction, info, dut, dur);
return(incrementalStateResult);
}
internal LoadIncrementalState Predict(LoadState state, double initialStiffness, StructureInfo info)
{
Vector<double> equilibrium = info.InitialLoad + state.Lambda * info.ReferenceLoad - info.Reaction(state.Displacement);
ILinearSolver mK = info.Stiffness(state.Displacement);
Vector<double> Dvt = mK.Solve(info.ReferenceLoad);
Vector<double> Dvr = mK.Solve(equilibrium);
double bergam = GetBergamParameter(initialStiffness, Dvt, info);
double DLambda = Scheme.Predict(Dvt, info.ReferenceLoad) * Math.Sign(bergam);
Vector<double> Dv = DLambda * Dvt + Dvr;
return new LoadIncrementalState(DLambda, Dv);
}
private void Helper2(IElementalAccessMatrix A, IElementalAccessVector b,
IElementalAccessVector x, ILinearSolver solver, IPreconditioner M, ILinearIteration iter)
{
Random r = new Random();
double K = r.NextDouble(), f = r.NextDouble(), gl = r.NextDouble(), gr = r.NextDouble();
assemble(A, b, K, f);
boundary(A, b, x, gl, gr);
double[] ans = solve(A, b, x, solver, M, iter);
double[] ref_Renamed = reference(b.Length - 1, K, f, gl, gr);
checkEqual(ans, ref_Renamed);
Blas.Default.Zero(A);
Blas.Default.Zero(b);
Blas.Default.Zero(x);
}
public IEnumerable <LoadState> Broadcast()
{
ILinearSolver mK0 = Info.Stiffness(State.Displacement);
Vector <double> Dv0 = mK0.Solve(Info.ReferenceLoad);
double k0 = Info.ReferenceLoad.DotProduct(Dv0);
while (true)
{
LoadIncrementalState prediction = Predictor.Predict(State, k0, Info);
State = State.Add(prediction);
Result <LoadIncrementalState> correctionResult = Corrector.Correct(State, prediction, Info);
if (correctionResult.IsSuccess)
{
State = State.Add(correctionResult.Value);
yield return(State);
}
else
{
break;
}
}
}
/// <summary> Constructor for AbstractMixedSolver, with CG as solver and default
/// linear iteration object.</summary>
public AbstractMixedSolver()
{
this.iter = new DefaultLinearIteration();
this.solver = new CGSolver();
blas = Blas.Default;
}
/// <summary> Assigns the solver.</summary>
public IterativeSolverPreconditioner(ILinearSolver preconditioner)
{
this.preconditioner = preconditioner;
}
/// <summary> Constructor for ShiftInvertEigenvalueTransformation. The matrix Am
/// must be of the same size as A, and it is overwritten.
/// </summary>
public ShiftInvertEigenvalueTransformation(IMatrix Am, IMatrix A) : base()
{
this.Am = Blas.Default.Copy(A, Am);
solver_ = new GMRESSolver();
}
