void wil_mat(void *out, void **gauge, void *in, double kappa, int dagger_bit, QudaPrecision precision, QudaGaugeParam &gauge_param) { void *inEven = in; void *inOdd = (char*)in + Vh*spinorSiteSize*precision; void *outEven = out; void *outOdd = (char*)out + Vh*spinorSiteSize*precision; wil_dslash(outOdd, gauge, inEven, 1, dagger_bit, precision, gauge_param); wil_dslash(outEven, gauge, inOdd, 0, dagger_bit, precision, gauge_param); // lastly apply the kappa term if (precision == QUDA_DOUBLE_PRECISION) xpay((double*)in, -kappa, (double*)out, V*spinorSiteSize); else xpay((float*)in, -(float)kappa, (float*)out, V*spinorSiteSize); }
void dslashRef() { // FIXME: remove once reference clover is finished if (dslash_type == QUDA_CLOVER_WILSON_DSLASH) { if (inv_param.matpc_type == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) { inv_param.matpc_type = QUDA_MATPC_EVEN_EVEN; } else if (inv_param.matpc_type == QUDA_MATPC_ODD_ODD_ASYMMETRIC) { inv_param.matpc_type = QUDA_MATPC_ODD_ODD; } } // compare to dslash reference implementation printfQuda("Calculating reference implementation..."); fflush(stdout); if (dslash_type == QUDA_CLOVER_WILSON_DSLASH || dslash_type == QUDA_WILSON_DSLASH) { switch (test_type) { case 0: wil_dslash(spinorRef->V(), hostGauge, spinor->V(), parity, dagger, inv_param.cpu_prec, gauge_param); break; case 1: wil_matpc(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.matpc_type, dagger, inv_param.cpu_prec, gauge_param); break; case 2: wil_mat(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, dagger, inv_param.cpu_prec, gauge_param); break; default: printfQuda("Test type not defined\n"); exit(-1); } } else { // twisted mass switch (test_type) { case 0: tm_dslash(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, parity, dagger, inv_param.cpu_prec, gauge_param); break; case 1: tm_matpc(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, inv_param.matpc_type, dagger, inv_param.cpu_prec, gauge_param); break; case 2: tm_mat(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, dagger, inv_param.cpu_prec, gauge_param); break; default: printfQuda("Test type not defined\n"); exit(-1); } } printfQuda("done.\n"); }
void tm_mat(void *out, void **gauge, void *in, double kappa, double mu, QudaTwistFlavorType flavor, int dagger_bit, QudaPrecision precision, QudaGaugeParam &gauge_param) { void *inEven = in; void *inOdd = (char*)in + Vh*spinorSiteSize*precision; void *outEven = out; void *outOdd = (char*)out + Vh*spinorSiteSize*precision; void *tmp = malloc(V*spinorSiteSize*precision); wil_dslash(outOdd, gauge, inEven, 1, dagger_bit, precision, gauge_param); wil_dslash(outEven, gauge, inOdd, 0, dagger_bit, precision, gauge_param); // apply the twist term to the full lattice twist_gamma5(tmp, in, dagger_bit, kappa, mu, flavor, V, QUDA_TWIST_GAMMA5_DIRECT, precision); // combine if (precision == QUDA_DOUBLE_PRECISION) xpay((double*)tmp, -kappa, (double*)out, V*spinorSiteSize); else xpay((float*)tmp, -(float)kappa, (float*)out, V*spinorSiteSize); free(tmp); }
// Apply the even-odd preconditioned Dirac operator void wil_matpc(void *outEven, void **gauge, void *inEven, double kappa, QudaMatPCType matpc_type, int daggerBit, QudaPrecision precision, QudaGaugeParam &gauge_param) { void *tmp = malloc(Vh*spinorSiteSize*precision); // FIXME: remove once reference clover is finished // full dslash operator if (matpc_type == QUDA_MATPC_EVEN_EVEN || matpc_type == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) { wil_dslash(tmp, gauge, inEven, 1, daggerBit, precision, gauge_param); wil_dslash(outEven, gauge, tmp, 0, daggerBit, precision, gauge_param); } else { wil_dslash(tmp, gauge, inEven, 0, daggerBit, precision, gauge_param); wil_dslash(outEven, gauge, tmp, 1, daggerBit, precision, gauge_param); } // lastly apply the kappa term double kappa2 = -kappa*kappa; if (precision == QUDA_DOUBLE_PRECISION) xpay((double*)inEven, kappa2, (double*)outEven, Vh*spinorSiteSize); else xpay((float*)inEven, (float)kappa2, (float*)outEven, Vh*spinorSiteSize); free(tmp); }
void tm_dslash(void *res, void **gaugeFull, void *spinorField, double kappa, double mu, QudaTwistFlavorType flavor, int oddBit, int daggerBit, QudaPrecision precision, QudaGaugeParam &gauge_param) { if (daggerBit) twist_gamma5(spinorField, spinorField, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(res, gaugeFull, spinorField, oddBit, daggerBit, precision, gauge_param); if (!daggerBit) { twist_gamma5(res, res, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); } else { twist_gamma5(spinorField, spinorField, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_DIRECT, precision); } }
void dslashRef() { // compare to dslash reference implementation printfQuda("Calculating reference implementation..."); fflush(stdout); if (dslash_type == QUDA_CLOVER_WILSON_DSLASH || dslash_type == QUDA_WILSON_DSLASH) { switch (test_type) { case 0: wil_dslash(spinorRef->V(), hostGauge, spinor->V(), parity, dagger, inv_param.cpu_prec, gauge_param); break; case 1: wil_matpc(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.matpc_type, dagger, inv_param.cpu_prec, gauge_param); break; case 2: wil_mat(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, dagger, inv_param.cpu_prec, gauge_param); break; case 3: wil_matpc(spinorTmp->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.matpc_type, QUDA_DAG_NO, inv_param.cpu_prec, gauge_param); wil_matpc(spinorRef->V(), hostGauge, spinorTmp->V(), inv_param.kappa, inv_param.matpc_type, QUDA_DAG_YES, inv_param.cpu_prec, gauge_param); break; case 4: wil_mat(spinorTmp->V(), hostGauge, spinor->V(), inv_param.kappa, QUDA_DAG_NO, inv_param.cpu_prec, gauge_param); wil_mat(spinorRef->V(), hostGauge, spinorTmp->V(), inv_param.kappa, QUDA_DAG_YES, inv_param.cpu_prec, gauge_param); break; default: printfQuda("Test type not defined\n"); exit(-1); } } else if (dslash_type == QUDA_TWISTED_MASS_DSLASH) { switch (test_type) { case 0: tm_dslash(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, parity, dagger, inv_param.cpu_prec, gauge_param); break; case 1: tm_matpc(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, inv_param.matpc_type, dagger, inv_param.cpu_prec, gauge_param); break; case 2: tm_mat(spinorRef->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, dagger, inv_param.cpu_prec, gauge_param); break; case 3: tm_matpc(spinorTmp->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, inv_param.matpc_type, QUDA_DAG_NO, inv_param.cpu_prec, gauge_param); tm_matpc(spinorRef->V(), hostGauge, spinorTmp->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, inv_param.matpc_type, QUDA_DAG_YES, inv_param.cpu_prec, gauge_param); break; case 4: tm_mat(spinorTmp->V(), hostGauge, spinor->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, QUDA_DAG_NO, inv_param.cpu_prec, gauge_param); tm_mat(spinorRef->V(), hostGauge, spinorTmp->V(), inv_param.kappa, inv_param.mu, inv_param.twist_flavor, QUDA_DAG_YES, inv_param.cpu_prec, gauge_param); break; default: printfQuda("Test type not defined\n"); exit(-1); } } else if (dslash_type == QUDA_DOMAIN_WALL_DSLASH) { switch (test_type) { case 0: dw_dslash(spinorRef->V(), hostGauge, spinor->V(), parity, dagger, gauge_param.cpu_prec, gauge_param, inv_param.mass); break; case 1: dw_matpc(spinorRef->V(), hostGauge, spinor->V(), kappa5, inv_param.matpc_type, dagger, gauge_param.cpu_prec, gauge_param, inv_param.mass); break; case 2: dw_mat(spinorRef->V(), hostGauge, spinor->V(), kappa5, dagger, gauge_param.cpu_prec, gauge_param, inv_param.mass); break; case 3: dw_matdagmat(spinorRef->V(), hostGauge, spinor->V(), kappa5, dagger, gauge_param.cpu_prec, gauge_param, inv_param.mass); break; default: printf("Test type not supported for domain wall\n"); exit(-1); } } else { printfQuda("Unsupported dslash_type\n"); exit(-1); } printfQuda("done.\n"); }
// Apply the even-odd preconditioned Dirac operator void tm_matpc(void *outEven, void **gauge, void *inEven, double kappa, double mu, QudaTwistFlavorType flavor, QudaMatPCType matpc_type, int daggerBit, QudaPrecision precision, QudaGaugeParam &gauge_param) { void *tmp = malloc(Vh*spinorSiteSize*precision); if (matpc_type == QUDA_MATPC_EVEN_EVEN_ASYMMETRIC) { wil_dslash(tmp, gauge, inEven, 1, daggerBit, precision, gauge_param); twist_gamma5(tmp, tmp, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(outEven, gauge, tmp, 0, daggerBit, precision, gauge_param); twist_gamma5(tmp, inEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_DIRECT, precision); } else if (matpc_type == QUDA_MATPC_ODD_ODD_ASYMMETRIC) { wil_dslash(tmp, gauge, inEven, 0, daggerBit, precision, gauge_param); twist_gamma5(tmp, tmp, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(outEven, gauge, tmp, 1, daggerBit, precision, gauge_param); twist_gamma5(tmp, inEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_DIRECT, precision); } else if (!daggerBit) { if (matpc_type == QUDA_MATPC_EVEN_EVEN) { wil_dslash(tmp, gauge, inEven, 1, daggerBit, precision, gauge_param); twist_gamma5(tmp, tmp, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(outEven, gauge, tmp, 0, daggerBit, precision, gauge_param); twist_gamma5(outEven, outEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); } else if (matpc_type == QUDA_MATPC_ODD_ODD) { wil_dslash(tmp, gauge, inEven, 0, daggerBit, precision, gauge_param); twist_gamma5(tmp, tmp, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(outEven, gauge, tmp, 1, daggerBit, precision, gauge_param); twist_gamma5(outEven, outEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); } } else { if (matpc_type == QUDA_MATPC_EVEN_EVEN) { twist_gamma5(inEven, inEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(tmp, gauge, inEven, 1, daggerBit, precision, gauge_param); twist_gamma5(tmp, tmp, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(outEven, gauge, tmp, 0, daggerBit, precision, gauge_param); twist_gamma5(inEven, inEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_DIRECT, precision); } else if (matpc_type == QUDA_MATPC_ODD_ODD) { twist_gamma5(inEven, inEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(tmp, gauge, inEven, 0, daggerBit, precision, gauge_param); twist_gamma5(tmp, tmp, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_INVERSE, precision); wil_dslash(outEven, gauge, tmp, 1, daggerBit, precision, gauge_param); twist_gamma5(inEven, inEven, daggerBit, kappa, mu, flavor, Vh, QUDA_TWIST_GAMMA5_DIRECT, precision); // undo } } // lastly apply the kappa term double kappa2 = -kappa*kappa; if (matpc_type == QUDA_MATPC_EVEN_EVEN || matpc_type == QUDA_MATPC_ODD_ODD) { if (precision == QUDA_DOUBLE_PRECISION) xpay((double*)inEven, kappa2, (double*)outEven, Vh*spinorSiteSize); else xpay((float*)inEven, (float)kappa2, (float*)outEven, Vh*spinorSiteSize); } else { if (precision == QUDA_DOUBLE_PRECISION) xpay((double*)tmp, kappa2, (double*)outEven, Vh*spinorSiteSize); else xpay((float*)tmp, (float)kappa2, (float*)outEven, Vh*spinorSiteSize); } free(tmp); }