void Qtm_minus_sym_psi(spinor * const l, spinor * const k){
Hopping_Matrix(EO, g_spinor_field[DUM_MATRIX+1], k);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX+1], -1., VOLUME/2);
Hopping_Matrix(OE, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1]);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX], -1., VOLUME/2);
mul_one_sub_mul_gamma5(l, k, g_spinor_field[DUM_MATRIX]);
}
void Mtm_minus_sym_psi_nocom(spinor * const l, spinor * const k) {
Hopping_Matrix_nocom(EO, g_spinor_field[DUM_MATRIX+1], k);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX+1], -1., VOLUME/2);
Hopping_Matrix_nocom(OE, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1]);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX], -1., VOLUME/2);
diff(l, k, g_spinor_field[DUM_MATRIX], VOLUME/2);
}
void M_minus_1_timesC(spinor * const Even_new, spinor * const Odd_new,
spinor * const Even, spinor * const Odd) {
/* Even sites */
Hopping_Matrix(EO, Even_new, Odd);
mul_one_pm_imu_inv(Even_new, 1., VOLUME/2);
/* Odd sites */
Hopping_Matrix(OE, Odd_new, Even);
mul_one_pm_imu_inv(Odd_new, 1., VOLUME/2);
}
void Mtm_plus_sym_block_psi(spinor * const l, spinor * const k, const int i) {
block * blk = &block_list[i];
int vol = (*blk).volume/2;
Block_H_psi(blk, &g_spinor_field[DUM_MATRIX+1][i*vol], k, EO);
mul_one_pm_imu_inv(&g_spinor_field[DUM_MATRIX+1][i*vol], +1., vol);
Block_H_psi(blk, &g_spinor_field[DUM_MATRIX][i*vol], &g_spinor_field[DUM_MATRIX+1][i*vol], OE);
mul_one_pm_imu_inv(&g_spinor_field[DUM_MATRIX][i*vol], +1., vol);
diff(l, k, &g_spinor_field[DUM_MATRIX][i*vol], vol);
return;
}
void Qtm_pm_psi_nocom(spinor * const l, spinor * const k){
/* Q_{-} */
Hopping_Matrix_nocom(EO, g_spinor_field[DUM_MATRIX+1], k);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX+1], -1., VOLUME/2);
Hopping_Matrix_nocom(OE, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1]);
mul_one_pm_imu_sub_mul_gamma5(g_spinor_field[DUM_MATRIX], k, g_spinor_field[DUM_MATRIX], -1.);
/* Q_{+} */
Hopping_Matrix_nocom(EO, l, g_spinor_field[DUM_MATRIX]);
mul_one_pm_imu_inv(l, +1., VOLUME/2);
Hopping_Matrix_nocom(OE, g_spinor_field[DUM_MATRIX+1], l);
mul_one_pm_imu_sub_mul_gamma5(l, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1], +1.);
}
void Qtm_pm_sym_psi(spinor * const l, spinor * const k){
/* Q_{-} */
Hopping_Matrix(EO, g_spinor_field[DUM_MATRIX+1], k);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX+1], -1., VOLUME/2);
Hopping_Matrix(OE, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1]);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX], -1., VOLUME/2);
diff(l, k, g_spinor_field[DUM_MATRIX], VOLUME/2);
gamma5(l, l, VOLUME/2);
/* Q_{+} */
Hopping_Matrix(EO, l, g_spinor_field[DUM_MATRIX]);
mul_one_pm_imu_inv(l, +1., VOLUME/2);
Hopping_Matrix(OE, g_spinor_field[DUM_MATRIX+1], l);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX], +1., VOLUME/2);
diff(l, k, g_spinor_field[DUM_MATRIX], VOLUME/2);
gamma5(l, l, VOLUME/2);
}
void Mtm_plus_block_psi(spinor * const l, spinor * const k, const int i) {
block * blk = &block_list[i];
int vol = (*blk).volume/2;
Block_H_psi(blk, g_spinor_field[DUM_MATRIX+1], k, EO);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX+1], +1., vol);
Block_H_psi(blk, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1], OE);
mul_one_pm_imu_sub_mul(l, k, g_spinor_field[DUM_MATRIX], +1., vol);
return;
}
void CGeoSmoother(spinor * const P, spinor * const Q, const int Ncy, const int dummy) {
spinor ** solver_field = NULL;
const int nr_sf = 5;
double musave = g_mu;
g_mu = g_mu1;
init_solver_field(&solver_field, VOLUMEPLUSRAND/2, nr_sf);
convert_lexic_to_eo(solver_field[0], solver_field[1], Q);
if(g_c_sw > 0)
assign_mul_one_sw_pm_imu_inv(EE,solver_field[2], solver_field[0], g_mu);
else
assign_mul_one_pm_imu_inv(solver_field[2], solver_field[0], +1., VOLUME/2);
Hopping_Matrix(OE, solver_field[4], solver_field[2]);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_mul_add_r(solver_field[4], +1., solver_field[1], VOLUME/2);
/* Do the inversion with the preconditioned */
/* matrix to get the odd sites */
gamma5(solver_field[4], solver_field[4], VOLUME/2);
if(g_c_sw > 0) {
cg_her(solver_field[3], solver_field[4], Ncy, 1.e-8, 1,
VOLUME/2, &Qsw_pm_psi);
Qsw_minus_psi(solver_field[3], solver_field[3]);
/* Reconstruct the even sites */
Hopping_Matrix(EO, solver_field[2], solver_field[3]);
assign_mul_one_sw_pm_imu_inv(EE,solver_field[4],solver_field[2], g_mu);
}
else {
cg_her(solver_field[3], solver_field[4], Ncy, 1.e-8, 1,
VOLUME/2, &Qtm_pm_psi);
Qtm_minus_psi(solver_field[3], solver_field[3]);
/* Reconstruct the even sites */
Hopping_Matrix(EO, solver_field[4], solver_field[3]);
mul_one_pm_imu_inv(solver_field[4], +1., VOLUME/2);
}
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_add_mul_r(solver_field[2], solver_field[4], +1., VOLUME/2);
convert_eo_to_lexic(P, solver_field[2], solver_field[3]);
g_mu = musave;
finalize_solver(solver_field, nr_sf);
return;
}
void H_eo_tm_inv_psi(spinor * const l, spinor * const k,
const int ieo, const double _sign) {
#if ((defined BGL && defined XLC) || defined _USE_TSPLITPAR)
Hopping_Matrix(ieo, l, k);
mul_one_pm_imu_inv(l, _sign, VOLUME/2);
#else
double ALIGN nrm = 1./(1.+g_mu*g_mu);
double sign=-1.;
complex double ALIGN z;
if(_sign < 0.){
sign = 1.;
}
z = nrm + (sign * nrm * g_mu) * I;
tm_times_Hopping_Matrix(ieo, l, k, z);
return;
#endif
}
void Mtm_plus_psi_nocom(spinor * const l, spinor * const k){
Hopping_Matrix_nocom(EO, g_spinor_field[DUM_MATRIX+1], k);
mul_one_pm_imu_inv(g_spinor_field[DUM_MATRIX+1], +1., VOLUME/2);
Hopping_Matrix_nocom(OE, g_spinor_field[DUM_MATRIX], g_spinor_field[DUM_MATRIX+1]);
mul_one_pm_imu_sub_mul(l, k, g_spinor_field[DUM_MATRIX], +1., VOLUME/2);
}
void Msap_eo_old(spinor * const P, spinor * const Q, const int Ncy, const int Niter) {
int blk, ncy = 0, eo, vol, vols;
spinor * r, * a, * b, * c;
double nrm;
double musave = g_mu;
double kappasave = g_kappa;
spinor * b_even, * b_odd, * a_even, * a_odd;
spinor ** solver_field = NULL;
// also get space for mrblk! 6 = 3+3
const int nr_sf = 6;
if(kappa_dflgen > 0) {
g_kappa = kappa_dfl;
}
if(mu_dflgen > -10) {
g_mu = mu_dfl;
// make sure the sign is correct!
if(g_mu*musave < 0) g_mu *= -1.;
}
boundary(g_kappa);
/*
* here it would be probably better to get the working fields as a parameter
* from the calling function
*/
vols = block_list[0].volume/2+block_list[0].spinpad;
vol = block_list[0].volume/2;
init_solver_field(&solver_field, nb_blocks*2*vols, nr_sf);
r = solver_field[0];
a = solver_field[1];
b = solver_field[2];
for(ncy = 0; ncy < Ncy; ncy++) {
/* compute the global residue */
/* this can be done more efficiently */
/* here only a naive implementation */
for(eo = 0; eo < 2; eo++) {
D_psi(r, P);
diff(r, Q, r, VOLUME);
nrm = square_norm(r, VOLUME, 1);
if(g_proc_id == 0 && g_debug_level > 2 && eo == 0) {
printf("Msap_eo: %d %1.3e mu = %e\n", ncy, nrm, g_mu/2./g_kappa);
fflush(stdout);
}
/* choose the even (odd) block */
// rely on nested parallelism
//
#ifdef TM_USE_OMP
# pragma omp parallel for private (a_even, a_odd, b_even, b_odd, c)
#endif
for (blk = 0; blk < nb_blocks; blk++) {
b_even = b + blk*2*vols;
b_odd = b +blk*2*vols + vols;
a_even = a + blk*2*vols;
a_odd = a + blk*2*vols + vols;
c = solver_field[3] + blk*vols;
if(block_list[blk].evenodd == eo) {
/* get part of r corresponding to block blk into b_even and b_odd */
copy_global_to_block_eo(b_even, b_odd, r, blk);
if(g_c_sw > 0) {
assign_mul_one_sw_pm_imu_inv_block(EE, a_even, b_even, g_mu, &block_list[blk]);
Block_H_psi(&block_list[blk], a_odd, a_even, OE);
/* a_odd = b_odd - a_odd */
diff(a_odd, b_odd, a_odd, vol);
mrblk(b_odd, a_odd, solver_field[3] + blk*2*3*vols, Niter, 1.e-31, 1, vol, &Msw_plus_block_psi, blk);
Block_H_psi(&block_list[blk], b_even, b_odd, EO);
assign(c, b_even, vol);
assign_mul_one_sw_pm_imu_inv_block(EE, b_even, c, g_mu, &block_list[blk]);
}
else {
assign_mul_one_pm_imu_inv(a_even, b_even, +1., vol);
Block_H_psi(&block_list[blk], a_odd, a_even, OE);
/* a_odd = b_odd - a_odd */
diff(a_odd, b_odd, a_odd, vol);
mrblk(b_odd, a_odd, solver_field[3] + blk*2*3*vols, Niter, 1.e-31, 1, vol, &Mtm_plus_block_psi, blk);
Block_H_psi(&block_list[blk], b_even, b_odd, EO);
mul_one_pm_imu_inv(b_even, +1., vol);
}
/* a_even = a_even - b_even */
diff(a_even, a_even, b_even, vol);
/* add even and odd part up to full spinor P */
add_eo_block_to_global(P, a_even, b_odd, blk);
}
}
}
}
finalize_solver(solver_field, nr_sf);
g_mu = musave;
g_kappa = kappasave;
boundary(g_kappa);
return;
}
void Msap_eo(spinor * const P, spinor * const Q, const int Ncy) {
int blk, ncy = 0, eo, vol;
spinor * r, * a, * b;
double nrm;
spinor * b_even, * b_odd, * a_even, * a_odd;
spinor ** solver_field = NULL;
const int nr_sf = 3;
/*
* here it would be probably better to get the working fields as a parameter
* from the calling function
*/
init_solver_field(&solver_field, VOLUME, nr_sf);
r = solver_field[0];
a = solver_field[1];
b = solver_field[2];
vol = block_list[0].volume/2;
b_even = b;
b_odd = b + vol + 1;
a_even = a;
a_odd = a + vol + 1;
for(ncy = 0; ncy < Ncy; ncy++) {
/* compute the global residue */
/* this can be done more efficiently */
/* here only a naive implementation */
for(eo = 0; eo < 2; eo++) {
D_psi(r, P);
diff(r, Q, r, VOLUME);
nrm = square_norm(r, VOLUME, 1);
if(g_proc_id == 0 && g_debug_level > 1 && eo == 1) {
printf("Msap: %d %1.3e\n", ncy, nrm);
}
/* choose the even (odd) block */
for (blk = 0; blk < nb_blocks; blk++) {
if(block_list[blk].evenodd == eo) {
/* get part of r corresponding to block blk into b_even and b_odd */
copy_global_to_block_eo(b_even, b_odd, r, blk);
assign_mul_one_pm_imu_inv(a_even, b_even, +1., vol);
Block_H_psi(&block_list[blk], a_odd, a_even, OE);
/* a_odd = a_odd - b_odd */
assign_mul_add_r(a_odd, -1., b_odd, vol);
mrblk(b_odd, a_odd, 3, 1.e-31, 1, vol, &Mtm_plus_block_psi, blk);
Block_H_psi(&block_list[blk], b_even, b_odd, EO);
mul_one_pm_imu_inv(b_even, +1., vol);
/* a_even = a_even - b_even */
assign_add_mul_r(a_even, b_even, -1., vol);
/* add even and odd part up to full spinor P */
add_eo_block_to_global(P, a_even, b_odd, blk);
}
}
}
}
finalize_solver(solver_field, nr_sf);
return;
}
