void DiracDomainWallPC::prepare(ColorSpinorField* &src, ColorSpinorField* &sol, ColorSpinorField &x, ColorSpinorField &b, const QudaSolutionType solType) const { // we desire solution to preconditioned system if (solType == QUDA_MATPC_SOLUTION || solType == QUDA_MATPCDAG_MATPC_SOLUTION) { src = &b; sol = &x; } else { // we desire solution to full system if (matpcType == QUDA_MATPC_EVEN_EVEN) { // src = b_e + k D_eo b_o DslashXpay(x.Odd(), b.Odd(), QUDA_EVEN_PARITY, b.Even(), kappa5); src = &(x.Odd()); sol = &(x.Even()); } else if (matpcType == QUDA_MATPC_ODD_ODD) { // src = b_o + k D_oe b_e DslashXpay(x.Even(), b.Even(), QUDA_ODD_PARITY, b.Odd(), kappa5); src = &(x.Even()); sol = &(x.Odd()); } else { errorQuda("MatPCType %d not valid for DiracDomainWallPC", matpcType); } // here we use final solution to store parity solution and parity source // b is now up for grabs if we want } }
void DiracStaggered::MdagM(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { if (!initDslash){ initDslashConstants(*fatGauge, in.Stride()); initStaggeredConstants(*fatGauge, *longGauge); } bool reset = newTmp(&tmp1, in); cudaColorSpinorField* mytmp = dynamic_cast<cudaColorSpinorField*>(&(tmp1->Even())); cudaColorSpinorField* ineven = dynamic_cast<cudaColorSpinorField*>(&(in.Even())); cudaColorSpinorField* inodd = dynamic_cast<cudaColorSpinorField*>(&(in.Odd())); cudaColorSpinorField* outeven = dynamic_cast<cudaColorSpinorField*>(&(out.Even())); cudaColorSpinorField* outodd = dynamic_cast<cudaColorSpinorField*>(&(out.Odd())); //even Dslash(*mytmp, *ineven, QUDA_ODD_PARITY); DslashXpay(*outeven, *mytmp, QUDA_EVEN_PARITY, *ineven, 4*mass*mass); //odd Dslash(*mytmp, *inodd, QUDA_EVEN_PARITY); DslashXpay(*outodd, *mytmp, QUDA_ODD_PARITY, *inodd, 4*mass*mass); deleteTmp(&tmp1, reset); }
// Full staggered operator void DiracStaggered::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { bool reset = newTmp(&tmp1, in.Even()); DslashXpay(out.Even(), in.Odd(), QUDA_EVEN_PARITY, *tmp1, 2*mass); DslashXpay(out.Odd(), in.Even(), QUDA_ODD_PARITY, *tmp1, 2*mass); deleteTmp(&tmp1, reset); }
// Apply the even-odd preconditioned clover-improved Dirac operator void DiracCloverPC::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { double kappa2 = -kappa*kappa; // FIXME: For asymmetric, a "DslashCxpay" kernel would improve performance. bool reset = newTmp(&tmp1, in); if (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) { bool reset = newTmp(&tmp2, in); // DiracCloverPC::Dslash applies A^{-1}Dslash Dslash(*tmp1, in, QUDA_ODD_PARITY); Clover(*tmp2, in, QUDA_EVEN_PARITY); // DiracWilson::Dslash applies only Dslash DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, *tmp2, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) { // FIXME: It would be nice if I could do something like: cudaColorSpinorField tmp3( in.param() ); // to save copying the data from 'in' bool reset = newTmp(&tmp2, in); // DiracCloverPC::Dslash applies A^{-1}Dslash Dslash(*tmp1, in, QUDA_EVEN_PARITY); Clover(*tmp2, in, QUDA_ODD_PARITY); // DiracWilson::Dslash applies only Dslash DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, *tmp2, kappa2); } else if (!dagger) { // symmetric preconditioning if (matpcType == QUDA_MATPC_EVEN_EVEN) { Dslash(*tmp1, in, QUDA_ODD_PARITY); DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { Dslash(*tmp1, in, QUDA_EVEN_PARITY); DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("Invalid matpcType"); } } else { // symmetric preconditioning, dagger if (matpcType == QUDA_MATPC_EVEN_EVEN) { CloverInv(out, in, QUDA_EVEN_PARITY); Dslash(*tmp1, out, QUDA_ODD_PARITY); DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { CloverInv(out, in, QUDA_ODD_PARITY); Dslash(*tmp1, out, QUDA_EVEN_PARITY); DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("MatPCType %d not valid for DiracCloverPC", matpcType); } } deleteTmp(&tmp1, reset); }
// Apply the even-odd preconditioned clover-improved Dirac operator void DiracCloverPC::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { double kappa2 = -kappa*kappa; // FIXME: For asymmetric, a "DslashCxpay" kernel would improve performance. bool reset = newTmp(&tmp1, in); if (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) { Dslash(*tmp1, in, QUDA_ODD_PARITY); Clover(out, in, QUDA_EVEN_PARITY); #ifdef MULTI_GPU // not safe to alias because of partial updates cudaColorSpinorField tmp3(in); #else // safe since out is not read after writing cudaColorSpinorField &tmp3 = out; #endif DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, tmp3, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) { Dslash(*tmp1, in, QUDA_EVEN_PARITY); Clover(out, in, QUDA_ODD_PARITY); #ifdef MULTI_GPU // not safe to alias because of partial updates cudaColorSpinorField tmp3(in); #else // safe since out is not read after writing cudaColorSpinorField &tmp3 = out; #endif DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, tmp3, kappa2); } else if (!dagger) { // symmetric preconditioning if (matpcType == QUDA_MATPC_EVEN_EVEN) { Dslash(*tmp1, in, QUDA_ODD_PARITY); DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { Dslash(*tmp1, in, QUDA_EVEN_PARITY); DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("Invalid matpcType"); } } else { // symmetric preconditioning, dagger if (matpcType == QUDA_MATPC_EVEN_EVEN) { CloverInv(out, in, QUDA_EVEN_PARITY); Dslash(*tmp1, out, QUDA_ODD_PARITY); DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { CloverInv(out, in, QUDA_ODD_PARITY); Dslash(*tmp1, out, QUDA_EVEN_PARITY); DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("MatPCType %d not valid for DiracCloverPC", matpcType); } } deleteTmp(&tmp1, reset); }
// Full staggered operator void DiracStaggered::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { if (!initDslash){ initDslashConstants(*fatGauge, in.Stride()); initStaggeredConstants(*fatGauge, *longGauge); } bool reset = newTmp(&tmp1, in.Even()); DslashXpay(out.Even(), in.Odd(), QUDA_EVEN_PARITY, *tmp1, 2*mass); DslashXpay(out.Odd(), in.Even(), QUDA_ODD_PARITY, *tmp1, 2*mass); deleteTmp(&tmp1, reset); }
void DiracStaggered::MdagM(ColorSpinorField &out, const ColorSpinorField &in) const { bool reset = newTmp(&tmp1, in); //even Dslash(tmp1->Even(), in.Even(), QUDA_ODD_PARITY); DslashXpay(out.Even(), tmp1->Even(), QUDA_EVEN_PARITY, in.Even(), 4*mass*mass); //odd Dslash(tmp1->Even(), in.Odd(), QUDA_EVEN_PARITY); DslashXpay(out.Odd(), tmp1->Even(), QUDA_ODD_PARITY, in.Odd(), 4*mass*mass); deleteTmp(&tmp1, reset); }
void DiracStaggeredPC::MdagM(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { if (!initDslash){ initDslashConstants(*fatGauge, in.Stride()); initStaggeredConstants(*fatGauge, *longGauge); } bool reset = newTmp(&tmp1, in); QudaParity parity = QUDA_INVALID_PARITY; QudaParity other_parity = QUDA_INVALID_PARITY; if (matpcType == QUDA_MATPC_EVEN_EVEN) { parity = QUDA_EVEN_PARITY; other_parity = QUDA_ODD_PARITY; } else if (matpcType == QUDA_MATPC_ODD_ODD) { parity = QUDA_ODD_PARITY; other_parity = QUDA_EVEN_PARITY; } else { errorQuda("Invalid matpcType(%d) in function\n", matpcType); } Dslash(*tmp1, in, other_parity); DslashXpay(out, *tmp1, parity, in, 4*mass*mass); deleteTmp(&tmp1, reset); }
// FIXME: create kernel to eliminate tmp void DiracClover::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { checkFullSpinor(out, in); cudaColorSpinorField *tmp=0; // this hack allows for tmp2 to be full or parity field if (tmp2) { if (tmp2->SiteSubset() == QUDA_FULL_SITE_SUBSET) tmp = &(tmp2->Even()); else tmp = tmp2; } bool reset = newTmp(&tmp, in.Even()); Clover(*tmp, in.Odd(), QUDA_ODD_PARITY); DslashXpay(out.Odd(), in.Even(), QUDA_ODD_PARITY, *tmp, -kappa); Clover(*tmp, in.Even(), QUDA_EVEN_PARITY); DslashXpay(out.Even(), in.Odd(), QUDA_EVEN_PARITY, *tmp, -kappa); deleteTmp(&tmp, reset); }
void DiracWilsonPC::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { double kappa2 = -kappa*kappa; bool reset = newTmp(&tmp1, in); if (matpcType == QUDA_MATPC_EVEN_EVEN) { Dslash(*tmp1, in, QUDA_ODD_PARITY); DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { Dslash(*tmp1, in, QUDA_EVEN_PARITY); DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("MatPCType %d not valid for DiracWilsonPC", matpcType); } deleteTmp(&tmp1, reset); }
// Apply the even-odd preconditioned clover-improved Dirac operator void DiracDomainWallPC::M(ColorSpinorField &out, const ColorSpinorField &in) const { if ( in.Ndim() != 5 || out.Ndim() != 5) errorQuda("Wrong number of dimensions\n"); double kappa2 = -kappa5*kappa5; bool reset = newTmp(&tmp1, in); if (matpcType == QUDA_MATPC_EVEN_EVEN) { Dslash(*tmp1, in, QUDA_ODD_PARITY); DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { Dslash(*tmp1, in, QUDA_EVEN_PARITY); DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("MatPCType %d not valid for DiracDomainWallPC", matpcType); } deleteTmp(&tmp1, reset); }
void DiracDomainWallPC::reconstruct(ColorSpinorField &x, const ColorSpinorField &b, const QudaSolutionType solType) const { if (solType == QUDA_MATPC_SOLUTION || solType == QUDA_MATPCDAG_MATPC_SOLUTION) { return; } // create full solution checkFullSpinor(x, b); if (matpcType == QUDA_MATPC_EVEN_EVEN) { // x_o = b_o + k D_oe x_e DslashXpay(x.Odd(), x.Even(), QUDA_ODD_PARITY, b.Odd(), kappa5); } else if (matpcType == QUDA_MATPC_ODD_ODD) { // x_e = b_e + k D_eo x_o DslashXpay(x.Even(), x.Odd(), QUDA_EVEN_PARITY, b.Even(), kappa5); } else { errorQuda("MatPCType %d not valid for DiracDomainWallPC", matpcType); } }
// Apply the even-odd preconditioned clover-improved Dirac operator void DiracCloverPC::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { double kappa2 = -kappa*kappa; bool reset1 = newTmp(&tmp1, in); if (matpcType == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) { // DiracCloverPC::Dslash applies A^{-1}Dslash Dslash(*tmp1, in, QUDA_ODD_PARITY); // DiracClover::DslashXpay applies (A - kappa^2 D) DiracClover::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD_ASYMMETRIC) { // DiracCloverPC::Dslash applies A^{-1}Dslash Dslash(*tmp1, in, QUDA_EVEN_PARITY); // DiracClover::DslashXpay applies (A - kappa^2 D) DiracClover::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else if (!dagger) { // symmetric preconditioning if (matpcType == QUDA_MATPC_EVEN_EVEN) { Dslash(*tmp1, in, QUDA_ODD_PARITY); DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { Dslash(*tmp1, in, QUDA_EVEN_PARITY); DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("Invalid matpcType"); } } else { // symmetric preconditioning, dagger if (matpcType == QUDA_MATPC_EVEN_EVEN) { CloverInv(out, in, QUDA_EVEN_PARITY); Dslash(*tmp1, out, QUDA_ODD_PARITY); DiracWilson::DslashXpay(out, *tmp1, QUDA_EVEN_PARITY, in, kappa2); } else if (matpcType == QUDA_MATPC_ODD_ODD) { CloverInv(out, in, QUDA_ODD_PARITY); Dslash(*tmp1, out, QUDA_EVEN_PARITY); DiracWilson::DslashXpay(out, *tmp1, QUDA_ODD_PARITY, in, kappa2); } else { errorQuda("MatPCType %d not valid for DiracCloverPC", matpcType); } } deleteTmp(&tmp1, reset1); }
void DiracStaggeredPC::MdagM(ColorSpinorField &out, const ColorSpinorField &in) const { bool reset = newTmp(&tmp1, in); QudaParity parity = QUDA_INVALID_PARITY; QudaParity other_parity = QUDA_INVALID_PARITY; if (matpcType == QUDA_MATPC_EVEN_EVEN) { parity = QUDA_EVEN_PARITY; other_parity = QUDA_ODD_PARITY; } else if (matpcType == QUDA_MATPC_ODD_ODD) { parity = QUDA_ODD_PARITY; other_parity = QUDA_EVEN_PARITY; } else { errorQuda("Invalid matpcType(%d) in function\n", matpcType); } Dslash(*tmp1, in, other_parity); DslashXpay(out, *tmp1, parity, in, 4*mass*mass); deleteTmp(&tmp1, reset); }
void DiracDomainWall::M(ColorSpinorField &out, const ColorSpinorField &in) const { checkFullSpinor(out, in); DslashXpay(out.Odd(), in.Even(), QUDA_ODD_PARITY, in.Odd(), -kappa5); DslashXpay(out.Even(), in.Odd(), QUDA_EVEN_PARITY, in.Even(), -kappa5); }
void DiracWilson::M(cudaColorSpinorField &out, const cudaColorSpinorField &in) const { checkFullSpinor(out, in); DslashXpay(out.Odd(), in.Even(), QUDA_ODD_PARITY, in.Odd(), -kappa); DslashXpay(out.Even(), in.Odd(), QUDA_EVEN_PARITY, in.Even(), -kappa); }
// Full staggered operator void DiracStaggered::M(ColorSpinorField &out, const ColorSpinorField &in) const { DslashXpay(out.Even(), in.Odd(), QUDA_EVEN_PARITY, in.Even(), 2*mass); DslashXpay(out.Odd(), in.Even(), QUDA_ODD_PARITY, in.Odd(), 2*mass); }