int invert_cloverdoublet_eo(spinor * const Even_new_s, spinor * const Odd_new_s,
spinor * const Even_new_c, spinor * const Odd_new_c,
spinor * const Even_s, spinor * const Odd_s,
spinor * const Even_c, spinor * const Odd_c,
const double precision, const int max_iter,
const int solver_flag, const int rel_prec) {
int iter = 0;
/* here comes the inversion using even/odd preconditioning */
if(g_proc_id == 0) {printf("# Using even/odd preconditioning!\n"); fflush(stdout);}
Msw_ee_inv_ndpsi(Even_new_s, Even_new_c,
Even_s, Even_c);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI], Even_new_s);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI+1], Even_new_c);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_mul_add_r(g_spinor_field[DUM_DERI], +1., Odd_s, VOLUME/2);
assign_mul_add_r(g_spinor_field[DUM_DERI+1], +1., Odd_c, VOLUME/2);
/* Do the inversion with the preconditioned */
/* matrix to get the odd sites */
/* Here we invert the hermitean operator squared */
if(g_proc_id == 0) {
printf("# Using CG for TMWILSON flavour doublet!\n");
fflush(stdout);
}
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
gamma5(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+1], VOLUME/2);
iter = cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec,
VOLUME/2, &Qsw_pm_ndpsi);
Qsw_dagger_ndpsi(Odd_new_s, Odd_new_c,
Odd_new_s, Odd_new_c);
/* Reconstruct the even sites */
Hopping_Matrix(EO, g_spinor_field[DUM_DERI], Odd_new_s);
Hopping_Matrix(EO, g_spinor_field[DUM_DERI+1], Odd_new_c);
Msw_ee_inv_ndpsi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3],
g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_add_mul_r(Even_new_s, g_spinor_field[DUM_DERI+2], +1., VOLUME/2);
assign_add_mul_r(Even_new_c, g_spinor_field[DUM_DERI+3], +1., VOLUME/2);
return(iter);
}
int invert_doublet_eo(spinor * const Even_new_s, spinor * const Odd_new_s,
spinor * const Even_new_c, spinor * const Odd_new_c,
spinor * const Even_s, spinor * const Odd_s,
spinor * const Even_c, spinor * const Odd_c,
const double precision, const int max_iter,
const int solver_flag, const int rel_prec,
solver_params_t solver_params, const ExternalInverter external_inverter,
const SloppyPrecision sloppy, const CompressionType compression) {
int iter = 0;
#ifdef TM_USE_QUDA
if( external_inverter==QUDA_INVERTER ) {
return invert_doublet_eo_quda( Even_new_s, Odd_new_s, Even_new_c, Odd_new_c,
Even_s, Odd_s, Even_c, Odd_c,
precision, max_iter,
solver_flag, rel_prec, 1,
sloppy, compression );
}
#endif
#ifdef HAVE_GPU
# ifdef TEMPORALGAUGE
if (usegpu_flag) {
gtrafo_eo_nd(Even_s, Odd_s, Even_c, Odd_c,
(spinor*const)NULL, (spinor*const)NULL, (spinor*const)NULL, (spinor*const)NULL,
GTRAFO_APPLY);
}
# endif
#endif /* HAVE_GPU*/
/* here comes the inversion using even/odd preconditioning */
if(g_proc_id == 0) {printf("# Using even/odd preconditioning!\n"); fflush(stdout);}
M_ee_inv_ndpsi(Even_new_s, Even_new_c,
Even_s, Even_c,
g_mubar, g_epsbar);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI], Even_new_s);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI+1], Even_new_c);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_mul_add_r(g_spinor_field[DUM_DERI], +1., Odd_s, VOLUME/2);
assign_mul_add_r(g_spinor_field[DUM_DERI+1], +1., Odd_c, VOLUME/2);
/* Do the inversion with the preconditioned */
/* matrix to get the odd sites */
/* Here we invert the hermitean operator squared */
if(g_proc_id == 0) {
printf("# Using CG for TMWILSON flavour doublet!\n");
fflush(stdout);
}
if ( external_inverter == NO_EXT_INV ){
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
gamma5(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+1], VOLUME/2);
#ifdef HAVE_GPU
if (usegpu_flag) { // GPU, mixed precision solver
# if ( defined TM_USE_MPI && defined PARALLELT )
iter = mixedsolve_eo_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec);
# elif ( !defined TM_USE_MPI && !defined PARALLELT )
iter = mixedsolve_eo_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec);
# else
printf("MPI and/or PARALLELT are not appropriately set for the GPU implementation. Aborting...\n");
exit(-1);
# endif
}
else { // CPU, conjugate gradient
iter = cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec,
VOLUME/2, &Qtm_pm_ndpsi);
}
#else // CPU, conjugate gradient
if(solver_flag == RGMIXEDCG){
iter = rg_mixed_cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
solver_params, max_iter, precision, rel_prec, VOLUME/2,
&Qtm_pm_ndpsi, &Qtm_pm_ndpsi_32);
}
else {
iter = cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec, VOLUME/2, &Qtm_pm_ndpsi);
}
#endif
Qtm_dagger_ndpsi(Odd_new_s, Odd_new_c,
Odd_new_s, Odd_new_c);
} // if(NO_EXT_INV)
#ifdef TM_USE_QPHIX
else if (external_inverter == QPHIX_INVERTER ) {
// using QPhiX, we invert M M^dagger y = b, so we don't need gamma_5 multiplications
iter = invert_eo_qphix_twoflavour(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, solver_flag, rel_prec,
solver_params, sloppy, compression);
// and it multiplies y internally by M^dagger, returning M^{-1} b as required
}
#endif // TM_USE_QPHIX
/* Reconstruct the even sites */
Hopping_Matrix(EO, g_spinor_field[DUM_DERI], Odd_new_s);
Hopping_Matrix(EO, g_spinor_field[DUM_DERI+1], Odd_new_c);
M_ee_inv_ndpsi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3],
g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
g_mubar, g_epsbar);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_add_mul_r(Even_new_s, g_spinor_field[DUM_DERI+2], +1., VOLUME/2);
assign_add_mul_r(Even_new_c, g_spinor_field[DUM_DERI+3], +1., VOLUME/2);
#ifdef HAVE_GPU
/* return from temporal gauge again */
# ifdef TEMPORALGAUGE
if (usegpu_flag) {
gtrafo_eo_nd(Even_s, Odd_s, Even_c, Odd_c, Even_new_s, Odd_new_s, Even_new_c, Odd_new_c,
GTRAFO_REVERT);
}
# endif
#endif
return(iter);
}
int invert_cloverdoublet_eo(spinor * const Even_new_s, spinor * const Odd_new_s,
spinor * const Even_new_c, spinor * const Odd_new_c,
spinor * const Even_s, spinor * const Odd_s,
spinor * const Even_c, spinor * const Odd_c,
const double precision, const int max_iter,
const int solver_flag, const int rel_prec, solver_params_t solver_params,
const ExternalInverter external_inverter, const SloppyPrecision sloppy, const CompressionType compression) {
int iter = 0;
#ifdef TM_USE_QUDA
if( external_inverter==QUDA_INVERTER ) {
return invert_doublet_eo_quda( Even_new_s, Odd_new_s, Even_new_c, Odd_new_c,
Even_s, Odd_s, Even_c, Odd_c,
precision, max_iter,
solver_flag, rel_prec, 1,
sloppy, compression );
}
#endif
/* here comes the inversion using even/odd preconditioning */
if(g_proc_id == 0) {printf("# Using even/odd preconditioning!\n"); fflush(stdout);}
Msw_ee_inv_ndpsi(Even_new_s, Even_new_c,
Even_s, Even_c);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI], Even_new_s);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI+1], Even_new_c);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_mul_add_r(g_spinor_field[DUM_DERI], +1., Odd_s, VOLUME/2);
assign_mul_add_r(g_spinor_field[DUM_DERI+1], +1., Odd_c, VOLUME/2);
if( external_inverter == NO_EXT_INV ){
/* Do the inversion with the preconditioned */
/* matrix to get the odd sites */
/* Here we invert the hermitean operator squared */
if(g_proc_id == 0) {
printf("# Using CG for TMWILSON flavour doublet!\n");
fflush(stdout);
}
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
gamma5(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+1], VOLUME/2);
if(solver_flag == RGMIXEDCG){
iter = rg_mixed_cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
solver_params, max_iter, precision, rel_prec, VOLUME/2,
&Qsw_pm_ndpsi, &Qsw_pm_ndpsi_32);
} else {
iter = cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec,
VOLUME/2, &Qsw_pm_ndpsi);
}
Qsw_dagger_ndpsi(Odd_new_s, Odd_new_c,
Odd_new_s, Odd_new_c);
} // if(NO_EXT_INV)
#ifdef TM_USE_QPHIX
else if (external_inverter == QPHIX_INVERTER ) {
// using QPhiX, we invert M M^dagger y = b, so we don't need gamma_5 multiplications
iter = invert_eo_qphix_twoflavour(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, solver_flag, rel_prec,
solver_params, sloppy, compression);
// and it multiplies y internally by M^dagger, returning M^{-1} b as required
}
#endif // TM_USE_QPHIX
/* Reconstruct the even sites */
Hopping_Matrix(EO, g_spinor_field[DUM_DERI], Odd_new_s);
Hopping_Matrix(EO, g_spinor_field[DUM_DERI+1], Odd_new_c);
Msw_ee_inv_ndpsi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3],
g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_add_mul_r(Even_new_s, g_spinor_field[DUM_DERI+2], +1., VOLUME/2);
assign_add_mul_r(Even_new_c, g_spinor_field[DUM_DERI+3], +1., VOLUME/2);
return(iter);
}
void ndpoly_heatbath(const int id) {
int j;
double temp;
monomial * mnl = &monomial_list[id];
(*mnl).energy0 = 0.;
random_spinor_field(g_chi_up_spinor_field[0], VOLUME/2, (*mnl).rngrepro);
(*mnl).energy0 = square_norm(g_chi_up_spinor_field[0], VOLUME/2, 1);
if(g_epsbar!=0.0 || phmc_exact_poly == 0){
random_spinor_field(g_chi_dn_spinor_field[0], VOLUME/2, (*mnl).rngrepro);
(*mnl).energy0 += square_norm(g_chi_dn_spinor_field[0], VOLUME/2, 1);
}
else {
zero_spinor_field(g_chi_dn_spinor_field[0], VOLUME/2);
}
if((g_proc_id == g_stdio_proc) && (g_debug_level > 2)) {
printf("PHMC: Here comes the computation of H_old with \n \n");
printf("PHMC: First: random spinors and their norm \n ");
printf("PHMC: OLD Ennergy UP %e \n", (*mnl).energy0);
printf("PHMC: OLD Energy DN + UP %e \n\n", (*mnl).energy0);
}
if(phmc_exact_poly==0){
QNon_degenerate(g_chi_up_spinor_field[1], g_chi_dn_spinor_field[1],
g_chi_up_spinor_field[0], g_chi_dn_spinor_field[0]);
for(j = 1; j < (phmc_dop_n_cheby); j++){
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
assign(g_chi_dn_spinor_field[0], g_chi_dn_spinor_field[1], VOLUME/2);
Q_tau1_min_cconst_ND(g_chi_up_spinor_field[1], g_chi_dn_spinor_field[1],
g_chi_up_spinor_field[0], g_chi_dn_spinor_field[0],
phmc_root[phmc_dop_n_cheby-2+j]);
}
Poly_tilde_ND(g_chi_up_spinor_field[0], g_chi_dn_spinor_field[0], phmc_ptilde_cheby_coef,
phmc_ptilde_n_cheby, g_chi_up_spinor_field[1], g_chi_dn_spinor_field[1]);
}
else if( phmc_exact_poly==1 && g_epsbar!=0.0) {
/* Attention this is Q * tau1, up/dn are exchanged in the input spinor */
/* this is used as an preconditioner */
QNon_degenerate(g_chi_up_spinor_field[1],g_chi_dn_spinor_field[1],
g_chi_dn_spinor_field[0],g_chi_up_spinor_field[0]);
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
assign(g_chi_dn_spinor_field[0], g_chi_dn_spinor_field[1], VOLUME/2);
/* solve Q*tau1*P(Q^2) *x=y */
cg_her_nd(g_chi_up_spinor_field[1],g_chi_dn_spinor_field[1],
g_chi_up_spinor_field[0],g_chi_dn_spinor_field[0],
1000,1.e-16,0,VOLUME/2, Qtau1_P_ND);
/* phi= Bdagger phi */
for(j = 1; j < (phmc_dop_n_cheby); j++){
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
assign(g_chi_dn_spinor_field[0], g_chi_dn_spinor_field[1], VOLUME/2);
Q_tau1_min_cconst_ND(g_chi_up_spinor_field[1], g_chi_dn_spinor_field[1],
g_chi_up_spinor_field[0], g_chi_dn_spinor_field[0],
phmc_root[phmc_dop_n_cheby-2+j]);
}
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
assign(g_chi_dn_spinor_field[0], g_chi_dn_spinor_field[1], VOLUME/2);
}
else if(phmc_exact_poly==1 && g_epsbar==0.0) {
Qtm_pm_psi(g_chi_up_spinor_field[1], g_chi_up_spinor_field[0]);
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
/* solve (Q+)*(Q-)*P((Q+)*(Q-)) *x=y */
cg_her(g_chi_up_spinor_field[1], g_chi_up_spinor_field[0],
1000,1.e-16,0,VOLUME/2, Qtm_pm_Ptm_pm_psi);
/* phi= Bdagger phi */
for(j = 1; j < (phmc_dop_n_cheby); j++){
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
Qtm_pm_min_cconst_nrm(g_chi_up_spinor_field[1],
g_chi_up_spinor_field[0],
phmc_root[phmc_dop_n_cheby-2+j]);
}
assign(g_chi_up_spinor_field[0], g_chi_up_spinor_field[1], VOLUME/2);
}
assign(mnl->pf, g_chi_up_spinor_field[0], VOLUME/2);
assign(mnl->pf2, g_chi_dn_spinor_field[0], VOLUME/2);
temp = square_norm(g_chi_up_spinor_field[0], VOLUME/2, 1);
if((g_proc_id == g_stdio_proc) && (g_debug_level > 2)) {
printf("PHMC: Then: evaluate Norm of pseudofermion heatbath BHB \n ");
printf("PHMC: Norm of BHB up squared %e \n", temp);
}
if(g_epsbar!=0.0 || phmc_exact_poly==0)
temp += square_norm(g_chi_dn_spinor_field[0], VOLUME/2, 1);
if((g_proc_id == g_stdio_proc) && (g_debug_level > 2)){
printf("PHMC: Norm of BHB up + BHB dn squared %e \n\n", temp);
}
if(g_proc_id == 0 && g_debug_level > 3) {
printf("called ndpoly_heatbath for id %d with g_running_phmc = %d\n", id, g_running_phmc);
}
return;
}
int invert_doublet_eo(spinor * const Even_new_s, spinor * const Odd_new_s,
spinor * const Even_new_c, spinor * const Odd_new_c,
spinor * const Even_s, spinor * const Odd_s,
spinor * const Even_c, spinor * const Odd_c,
const double precision, const int max_iter,
const int solver_flag, const int rel_prec) {
int iter = 0;
#ifdef HAVE_GPU
# ifdef TEMPORALGAUGE
/* initialize temporal gauge here */
int retval;
double dret1, dret2;
double plaquette1 = 0.0;
double plaquette2 = 0.0;
if (usegpu_flag) {
/* need VOLUME here (not N=VOLUME/2)*/
if ((retval = init_temporalgauge_trafo(VOLUME, g_gauge_field)) != 0 ) { // initializes the transformation matrices
if (g_proc_id == 0) printf("Error while gauge fixing to temporal gauge. Aborting...\n"); // g_tempgauge_field as a copy of g_gauge_field
exit(200);
}
/* do trafo */
plaquette1 = measure_plaquette(g_gauge_field);
apply_gtrafo(g_gauge_field, g_trafo); // transformation of the gauge field
plaquette2 = measure_plaquette(g_gauge_field);
if (g_proc_id == 0) printf("\tPlaquette before gauge fixing: %.16e\n", plaquette1/6./VOLUME);
if (g_proc_id == 0) printf("\tPlaquette after gauge fixing: %.16e\n", plaquette2/6./VOLUME);
/* do trafo to odd_s part of source */
dret1 = square_norm(Odd_s, VOLUME/2 , 1);
apply_gtrafo_spinor_odd(Odd_s, g_trafo); // odd spinor transformation, strange
dret2 = square_norm(Odd_s, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
/* do trafo to odd_c part of source */
dret1 = square_norm(Odd_c, VOLUME/2 , 1);
apply_gtrafo_spinor_odd(Odd_c, g_trafo); // odd spinor transformation, charm
dret2 = square_norm(Odd_c, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
/* do trafo to even_s part of source */
dret1 = square_norm(Even_s, VOLUME/2 , 1);
apply_gtrafo_spinor_even(Even_s, g_trafo); // even spinor transformation, strange
dret2 = square_norm(Even_s, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
/* do trafo to even_c part of source */
dret1 = square_norm(Even_c, VOLUME/2 , 1);
apply_gtrafo_spinor_even(Even_c, g_trafo); // even spinor transformation, charm
dret2 = square_norm(Even_c, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
# ifdef MPI
xchange_gauge(g_gauge_field);
# endif
}
# endif
#endif /* HAVE_GPU*/
/* here comes the inversion using even/odd preconditioning */
if(g_proc_id == 0) {printf("# Using even/odd preconditioning!\n"); fflush(stdout);}
M_ee_inv_ndpsi(Even_new_s, Even_new_c,
Even_s, Even_c,
g_mubar, g_epsbar);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI], Even_new_s);
Hopping_Matrix(OE, g_spinor_field[DUM_DERI+1], Even_new_c);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_mul_add_r(g_spinor_field[DUM_DERI], +1., Odd_s, VOLUME/2);
assign_mul_add_r(g_spinor_field[DUM_DERI+1], +1., Odd_c, VOLUME/2);
/* Do the inversion with the preconditioned */
/* matrix to get the odd sites */
/* Here we invert the hermitean operator squared */
if(g_proc_id == 0) {
printf("# Using CG for TMWILSON flavour doublet!\n");
fflush(stdout);
}
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
gamma5(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+1], VOLUME/2);
#ifdef HAVE_GPU
if (usegpu_flag) { // GPU, mixed precision solver
# if defined(MPI) && defined(PARALLELT)
iter = mixedsolve_eo_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec);
# elif !defined(MPI) && !defined(PARALLELT)
iter = mixedsolve_eo_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec);
# else
printf("MPI and/or PARALLELT are not appropriately set for the GPU implementation. Aborting...\n");
exit(-1);
# endif
}
else { // CPU, conjugate gradient
iter = cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec,
VOLUME/2, &Qtm_pm_ndpsi);
}
#else // CPU, conjugate gradient
iter = cg_her_nd(Odd_new_s, Odd_new_c, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
max_iter, precision, rel_prec,
VOLUME/2, &Qtm_pm_ndpsi);
#endif
Qtm_dagger_ndpsi(Odd_new_s, Odd_new_c,
Odd_new_s, Odd_new_c);
/* Reconstruct the even sites */
Hopping_Matrix(EO, g_spinor_field[DUM_DERI], Odd_new_s);
Hopping_Matrix(EO, g_spinor_field[DUM_DERI+1], Odd_new_c);
M_ee_inv_ndpsi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3],
g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
g_mubar, g_epsbar);
/* The sign is plus, since in Hopping_Matrix */
/* the minus is missing */
assign_add_mul_r(Even_new_s, g_spinor_field[DUM_DERI+2], +1., VOLUME/2);
assign_add_mul_r(Even_new_c, g_spinor_field[DUM_DERI+3], +1., VOLUME/2);
#ifdef HAVE_GPU
/* return from temporal gauge again */
# ifdef TEMPORALGAUGE
if (usegpu_flag) {
/* undo trafo */
/* apply_inv_gtrafo(g_gauge_field, g_trafo);*/
/* copy back the saved original field located in g_tempgauge_field -> update necessary*/
plaquette1 = measure_plaquette(g_gauge_field);
copy_gauge_field(g_gauge_field, g_tempgauge_field);
g_update_gauge_copy = 1;
plaquette2 = measure_plaquette(g_gauge_field);
if (g_proc_id == 0) printf("\tPlaquette before inverse gauge fixing: %.16e\n", plaquette1/6./VOLUME);
if (g_proc_id == 0) printf("\tPlaquette after inverse gauge fixing: %.16e\n", plaquette2/6./VOLUME);
/* undo trafo to source Even_s */
dret1 = square_norm(Even_s, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_even(Even_s, g_trafo);
dret2 = square_norm(Even_s, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
/* undo trafo to source Even_c */
dret1 = square_norm(Even_c, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_even(Even_c, g_trafo);
dret2 = square_norm(Even_c, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
/* undo trafo to source Odd_s */
dret1 = square_norm(Odd_s, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_odd(Odd_s, g_trafo);
dret2 = square_norm(Odd_s, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
/* undo trafo to source Odd_c */
dret1 = square_norm(Odd_c, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_odd(Odd_c, g_trafo);
dret2 = square_norm(Odd_c, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
// Even_new_s
dret1 = square_norm(Even_new_s, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_even(Even_new_s, g_trafo);
dret2 = square_norm(Even_new_s, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
// Even_new_c
dret1 = square_norm(Even_new_c, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_even(Even_new_c, g_trafo);
dret2 = square_norm(Even_new_c, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
// Odd_new_s
dret1 = square_norm(Odd_new_s, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_odd(Odd_new_s, g_trafo);
dret2 = square_norm(Odd_new_s, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
// Odd_new_c
dret1 = square_norm(Odd_new_c, VOLUME/2 , 1);
apply_inv_gtrafo_spinor_odd(Odd_new_c, g_trafo);
dret2 = square_norm(Odd_new_c, VOLUME/2, 1);
if (g_proc_id == 0) printf("\tsquare norm before gauge fixing: %.16e\n", dret1);
if (g_proc_id == 0) printf("\tsquare norm after gauge fixing: %.16e\n", dret2);
finalize_temporalgauge();
# ifdef MPI
xchange_gauge(g_gauge_field);
# endif
}
# endif
#endif
return(iter);
}
