portelli/Grid
1
0
Fork 0
mirror of https://github.com/paboyle/Grid.git synced 2025-04-24 20:55:55 +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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Grid/algorithms/LinearOperator.h
View File

@ -322,7 +322,7 @@ public:
};
template<class Field>
class HermitianSchurOperatorBase : public LinearOperatorBase<Field>
class NonHermitianSchurOperatorBase : public LinearOperatorBase<Field>
{
public:
virtual RealD Mpc (const Field& in, Field& out) = 0;
@ -334,16 +334,10 @@ public:
no = MpcDag(tmp,out);
}
virtual void HermOpAndNorm(const Field& in, Field& out, RealD& n1, RealD& n2) {
out.Checkerboard() = in.Checkerboard();
Mpc(in, out);
ComplexD dot = innerProduct(in,out); n1 = real(dot);
n2 = norm2(out);
assert(0);
}
virtual void HermOp(const Field& in, Field& out) {
RealD n1, n2;
HermOpAndNorm(in, out, n1, n2);
assert(0);
}
void Op(const Field& in, Field& out) {
Mpc(in, out);
@ -361,11 +355,11 @@ public:
};
template<class Matrix, class Field>
class HermitianSchurDiagMooeeOperator : public HermitianSchurOperatorBase<Field>
class NonHermitianSchurDiagMooeeOperator : public NonHermitianSchurOperatorBase<Field>
{
public:
Matrix& _Mat;
HermitianSchurDiagMooeeOperator(Matrix& Mat): _Mat(Mat){};
NonHermitianSchurDiagMooeeOperator(Matrix& Mat): _Mat(Mat){};
virtual RealD Mpc(const Field& in, Field& out) {
Field tmp(in.Grid());
tmp.Checkerboard() = !in.Checkerboard();
@ -392,13 +386,13 @@ public:
};
template<class Matrix,class Field>
class HermitianSchurDiagOneOperator : public HermitianSchurOperatorBase<Field>
class NonHermitianSchurDiagOneOperator : public NonHermitianSchurOperatorBase<Field>
{
protected:
Matrix &_Mat;
public:
HermitianSchurDiagOneOperator (Matrix& Mat): _Mat(Mat){};
NonHermitianSchurDiagOneOperator (Matrix& Mat): _Mat(Mat){};
virtual RealD Mpc(const Field& in, Field& out) {
Field tmp(in.Grid());
@ -422,13 +416,13 @@ public:
};
template<class Matrix, class Field>
class HermitianSchurDiagTwoOperator : public HermitianSchurOperatorBase<Field>
class NonHermitianSchurDiagTwoOperator : public NonHermitianSchurOperatorBase<Field>
{
protected:
Matrix& _Mat;
public:
HermitianSchurDiagTwoOperator(Matrix& Mat): _Mat(Mat){};
NonHermitianSchurDiagTwoOperator(Matrix& Mat): _Mat(Mat){};
virtual RealD Mpc(const Field& in, Field& out) {
Field tmp(in.Grid());

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);
}
};
}

2
tests/solver/Test_wilsonclover_bicgstab_prec.cc
View File

@ -77,7 +77,7 @@ int main (int argc, char ** argv)
pickCheckerboard(Odd, src_o, src);
result_o = Zero();
HermitianSchurDiagMooeeOperator<WilsonCloverFermionR,LatticeFermion> HermOp(Dw);
NonHermitianSchurDiagMooeeOperator<WilsonCloverFermionR,LatticeFermion> HermOp(Dw);
BiCGSTAB<LatticeFermion> CG(1.0e-8,10000);
CG(HermOp, src_o, result_o);

2
tests/solver/Test_wilsonclover_bicgstab_schur.cc
View File

@ -73,7 +73,7 @@ int main (int argc, char ** argv)
WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
BiCGSTAB<LatticeFermion> CG(1.0e-8,10000);
HermitianSchurRedBlackDiagMooeeSolve<LatticeFermion> SchurSolver(CG);
NonHermitianSchurRedBlackDiagMooeeSolve<LatticeFermion> SchurSolver(CG);
SchurSolver(Dw, src, result);

2
tests/solver/Test_wilsonclover_bicgstab_unprec.cc
View File

@ -72,7 +72,7 @@ int main (int argc, char ** argv)
RealD csw_t = 1.0;
WilsonCloverFermionR Dw(Umu, Grid, RBGrid, mass, csw_r, csw_t);
HermitianLinearOperator<WilsonCloverFermionR,LatticeFermion> HermOp(Dw);
NonHermitianLinearOperator<WilsonCloverFermionR,LatticeFermion> HermOp(Dw);
BiCGSTAB<LatticeFermion> CG(1.0e-8,10000);
CG(HermOp,src,result);

8
tests/solver/Test_wilsonclover_mixedbicgstab_prec.cc
View File

@ -80,16 +80,16 @@ int main (int argc, char ** argv)
result_o_2.Checkerboard() = Odd;
result_o_2 = Zero();
HermitianSchurDiagMooeeOperator<WilsonCloverFermionD, LatticeFermionD> HermOpEO_d(Dw_d);
HermitianSchurDiagMooeeOperator<WilsonCloverFermionF, LatticeFermionF> HermOpEO_f(Dw_f);
NonHermitianSchurDiagMooeeOperator<WilsonCloverFermionD, LatticeFermionD> NonHermOpEO_d(Dw_d);
NonHermitianSchurDiagMooeeOperator<WilsonCloverFermionF, LatticeFermionF> NonHermOpEO_f(Dw_f);
std::cout << GridLogMessage << "::::::::::::: Starting mixed CG" << std::endl;
MixedPrecisionBiCGSTAB<LatticeFermionD, LatticeFermionF> mCG(1.0e-8, 10000, 50, FrbGrid_f, HermOpEO_f, HermOpEO_d);
MixedPrecisionBiCGSTAB<LatticeFermionD, LatticeFermionF> mCG(1.0e-8, 10000, 50, FrbGrid_f, NonHermOpEO_f, NonHermOpEO_d);
mCG(src_o, result_o);
std::cout << GridLogMessage << "::::::::::::: Starting regular CG" << std::endl;
BiCGSTAB<LatticeFermionD> CG(1.0e-8, 10000);
CG(HermOpEO_d, src_o, result_o_2);
CG(NonHermOpEO_d, src_o, result_o_2);
LatticeFermionD diff_o(FrbGrid_d);
RealD diff = axpy_norm(diff_o, -1.0, result_o, result_o_2);