portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-06-17 15:27:06 +01:00
Code Releases Activity

Fix naming conventions to be consistent with Peter

Browse Source
This commit is contained in:
David Murphy
2019-12-11 11:46:18 -05:00
parent 4180a4a8a7
commit 843ca9350a
8 changed files with 37 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
Grid/algorithms/iterative/BiCGSTAB.h
View File

@ -62,7 +62,7 @@ class BiCGSTAB : public OperatorFunction<Field>
conformable(psi, src);
RealD cp(0), rho(1), rho_prev(0), alpha(1), beta(0), omega(1);
RealD a(0), bo(0), d(0), b(0), ssq(0), qq(0);
RealD a(0), bo(0), b(0), ssq(0);
Field p(src);
Field r(src);
@ -79,7 +79,8 @@ class BiCGSTAB : public OperatorFunction<Field>
RealD guess = norm2(psi);
assert(std::isnan(guess) == 0);
Linop.HermOpAndNorm(psi, v, d, b);
Linop.Op(psi, v);
b = norm2(v);
r = src - v;
rhat = r;
@ -131,7 +132,7 @@ class BiCGSTAB : public OperatorFunction<Field>
LinalgTimer.Stop();
MatrixTimer.Start();
Linop.HermOp(p,v);
Linop.Op(p,v);
MatrixTimer.Stop();
LinalgTimer.Start();
@ -155,7 +156,7 @@ class BiCGSTAB : public OperatorFunction<Field>
LinalgTimer.Stop();
MatrixTimer.Start();
Linop.HermOp(s,t);
Linop.Op(s,t);
MatrixTimer.Stop();
LinalgTimer.Start();
@ -181,7 +182,7 @@ class BiCGSTAB : public OperatorFunction<Field>
if(cp <= rsq)
{
SolverTimer.Stop();
Linop.HermOpAndNorm(psi, v, d, qq);
Linop.Op(psi, v);
p = v - src;
RealD srcnorm = sqrt(norm2(src));

2
Grid/algorithms/iterative/BiCGSTABMixedPrec.h
View File

@ -105,7 +105,7 @@ class MixedPrecisionBiCGSTAB : public LinearFunction<FieldD>
for(outer_iter = 0; outer_iter < MaxOuterIterations; outer_iter++)
{
// Compute double precision rsd and also new RHS vector.
Linop_d.HermOp(sol_d, tmp_d);
Linop_d.Op(sol_d, tmp_d);
RealD norm = axpy_norm(src_d, -1., tmp_d, src_d_in); //src_d is residual vector
std::cout << GridLogMessage << "MixedPrecisionBiCGSTAB: Outer iteration " << outer_iter << " residual " << norm << " target " << stop << std::endl;

28
Grid/algorithms/iterative/SchurRedBlack.h
View File

@ -405,14 +405,14 @@ namespace Grid {
}
};
template<class Field> class HermitianSchurRedBlackDiagMooeeSolve : public SchurRedBlackBase<Field>
template<class Field> class NonHermitianSchurRedBlackDiagMooeeSolve : public SchurRedBlackBase<Field>
{
public:
typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
HermitianSchurRedBlackDiagMooeeSolve(OperatorFunction<Field>& HermitianRBSolver, const bool initSubGuess = false,
NonHermitianSchurRedBlackDiagMooeeSolve(OperatorFunction<Field>& RBSolver, const bool initSubGuess = false,
const bool _solnAsInitGuess = false)
: SchurRedBlackBase<Field>(HermitianRBSolver, initSubGuess, _solnAsInitGuess) {};
: SchurRedBlackBase<Field>(RBSolver, initSubGuess, _solnAsInitGuess) {};
//////////////////////////////////////////////////////
// Override RedBlack specialisation
@ -458,14 +458,14 @@ namespace Grid {
virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)
{
HermitianSchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
this->_HermitianRBSolver(_HermOpEO, src_o, sol_o); assert(sol_o.Checkerboard() == Odd);
NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
this->_HermitianRBSolver(_OpEO, src_o, sol_o); assert(sol_o.Checkerboard() == Odd);
}
virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o, std::vector<Field>& sol_o)
{
HermitianSchurDiagMooeeOperator<Matrix,Field> _HermOpEO(_Matrix);
this->_HermitianRBSolver(_HermOpEO, src_o, sol_o);
NonHermitianSchurDiagMooeeOperator<Matrix,Field> _OpEO(_Matrix);
this->_HermitianRBSolver(_OpEO, src_o, sol_o);
}
};
@ -547,7 +547,7 @@ namespace Grid {
}
};
template<class Field> class HermitianSchurRedBlackDiagTwoSolve : public SchurRedBlackBase<Field>
template<class Field> class NonHermitianSchurRedBlackDiagTwoSolve : public SchurRedBlackBase<Field>
{
public:
typedef CheckerBoardedSparseMatrixBase<Field> Matrix;
@ -555,9 +555,9 @@ namespace Grid {
/////////////////////////////////////////////////////
// Wrap the usual normal equations Schur trick
/////////////////////////////////////////////////////
HermitianSchurRedBlackDiagTwoSolve(OperatorFunction<Field>& HermitianRBSolver, const bool initSubGuess = false,
NonHermitianSchurRedBlackDiagTwoSolve(OperatorFunction<Field>& RBSolver, const bool initSubGuess = false,
const bool _solnAsInitGuess = false)
: SchurRedBlackBase<Field>(HermitianRBSolver, initSubGuess, _solnAsInitGuess) {};
: SchurRedBlackBase<Field>(RBSolver, initSubGuess, _solnAsInitGuess) {};
virtual void RedBlackSource(Matrix& _Matrix, const Field& src, Field& src_e, Field& src_o)
{
@ -606,14 +606,14 @@ namespace Grid {
virtual void RedBlackSolve(Matrix& _Matrix, const Field& src_o, Field& sol_o)
{
HermitianSchurDiagTwoOperator<Matrix,Field> _HermOpEO(_Matrix);
this->_HermitianRBSolver(_HermOpEO, src_o, sol_o);
NonHermitianSchurDiagTwoOperator<Matrix,Field> _OpEO(_Matrix);
this->_HermitianRBSolver(_OpEO, src_o, sol_o);
};
virtual void RedBlackSolve(Matrix& _Matrix, const std::vector<Field>& src_o, std::vector<Field>& sol_o)
{
SchurDiagTwoOperator<Matrix,Field> _HermOpEO(_Matrix);
this->_HermitianRBSolver(_HermOpEO, src_o, sol_o);
NonHermitianSchurDiagTwoOperator<Matrix,Field> _OpEO(_Matrix);
this->_HermitianRBSolver(_OpEO, src_o, sol_o);
}
};
}