/* P output = solution , Q input = source */
int cg_mms_tm(spinor * const P, spinor * const Q, const int max_iter,
double eps_sq, const int rel_prec, const int N, matrix_mult f) {
static double normsq, pro, err, alpha_cg = 1., beta_cg = 0., squarenorm;
int iteration, im, append = 0;
char filename[100];
static double gamma, alpham1;
int const cg_mms_default_precision = 32;
double tmp_mu = g_mu;
WRITER * writer = NULL;
paramsInverterInfo *inverterInfo = NULL;
paramsPropagatorFormat *propagatorFormat = NULL;
spinor * temp_save; //used to save all the masses
spinor ** solver_field = NULL;
const int nr_sf = 5;
init_solver_field(&solver_field, VOLUMEPLUSRAND, nr_sf);
init_mms_tm(g_no_extra_masses);
/* currently only implemented for P=0 */
zero_spinor_field(P, N);
/* Value of the bare MMS-masses (\mu^2 - \mu_0^2) */
for(im = 0; im < g_no_extra_masses; im++) {
sigma[im] = g_extra_masses[im]*g_extra_masses[im] - g_mu*g_mu;
assign(xs_mms_solver[im], P, N);
assign(ps_mms_solver[im], Q, N);
zitam1[im] = 1.0;
zita[im] = 1.0;
alphas[im] = 1.0;
betas[im] = 0.0;
}
squarenorm = square_norm(Q, N, 1);
assign(solver_field[0], P, N);
/* normsp = square_norm(P, N, 1); */
/* initialize residue r and search vector p */
/* if(normsp == 0){ */
/* currently only implemented for P=0 */
if(1) {
/* if a starting solution vector equal to zero is chosen */
assign(solver_field[1], Q, N);
assign(solver_field[2], Q, N);
normsq = square_norm(Q, N, 1);
}
else{
/* if a starting solution vector different from zero is chosen */
f(solver_field[3], solver_field[0]);
diff(solver_field[1], Q, solver_field[3], N);
assign(solver_field[2], solver_field[1], N);
normsq = square_norm(solver_field[2], N, 1);
}
/* main loop */
for(iteration = 0; iteration < max_iter; iteration++) {
/* Q^2*p and then (p,Q^2*p) */
f(solver_field[4], solver_field[2]);
pro = scalar_prod_r(solver_field[2], solver_field[4], N, 1);
/* For the update of the coeff. of the shifted pol. we need alpha_cg(i-1) and alpha_cg(i).
This is the reason why we need this double definition of alpha */
alpham1 = alpha_cg;
/* Compute alpha_cg(i+1) */
alpha_cg = normsq/pro;
for(im = 0; im < g_no_extra_masses; im++) {
/* Now gamma is a temp variable that corresponds to zita(i+1) */
gamma = zita[im]*alpham1/(alpha_cg*beta_cg*(1.-zita[im]/zitam1[im])
+ alpham1*(1.+sigma[im]*alpha_cg));
/* Now zita(i-1) is put equal to the old zita(i) */
zitam1[im] = zita[im];
/* Now zita(i+1) is updated */
zita[im] = gamma;
/* Update of alphas(i) = alpha_cg(i)*zita(i+1)/zita(i) */
alphas[im] = alpha_cg*zita[im]/zitam1[im];
/* Compute xs(i+1) = xs(i) + alphas(i)*ps(i) */
assign_add_mul_r(xs_mms_solver[im], ps_mms_solver[im], alphas[im], N);
}
/* Compute x_(i+1) = x_i + alpha_cg(i+1) p_i */
assign_add_mul_r(solver_field[0], solver_field[2], alpha_cg, N);
/* Compute r_(i+1) = r_i - alpha_cg(i+1) Qp_i */
assign_add_mul_r(solver_field[1], solver_field[4], -alpha_cg, N);
/* Check whether the precision eps_sq is reached */
err = square_norm(solver_field[1], N, 1);
if(g_debug_level > 2 && g_proc_id == g_stdio_proc) {
printf("CGMMS iteration: %d residue: %g\n", iteration, err); fflush( stdout );
}
if( ((err <= eps_sq) && (rel_prec == 0)) ||
((err <= eps_sq*squarenorm) && (rel_prec == 1)) ) {
assign(P, solver_field[0], N);
f(solver_field[2], P);
diff(solver_field[3], solver_field[2], Q, N);
err = square_norm(solver_field[3], N, 1);
if(g_debug_level > 0 && g_proc_id == g_stdio_proc) {
printf("# CG MMS true residue at final iteration (%d) was %g.\n", iteration, err);
fflush( stdout);
}
g_sloppy_precision = 0;
g_mu = tmp_mu;
/* save all the results of (Q^dagger Q)^(-1) \gamma_5 \phi */
/* here ... */
/* when im == -1 save the base mass*/
for(im = -1; im < g_no_extra_masses; im++) {
if(im==-1) {
temp_save=solver_field[0];
} else {
temp_save=xs_mms_solver[im];
}
if(SourceInfo.type != 1) {
if (PropInfo.splitted) {
sprintf(filename, "%s.%.4d.%.2d.%.2d.cgmms.%.2d.inverted", SourceInfo.basename, SourceInfo.nstore, SourceInfo.t, SourceInfo.ix, im+1);
} else {
sprintf(filename, "%s.%.4d.%.2d.cgmms.%.2d.inverted", SourceInfo.basename, SourceInfo.nstore, SourceInfo.t, im+1);
}
}
else {
sprintf(filename, "%s.%.4d.%.5d.cgmms.%.2d.0", SourceInfo.basename, SourceInfo.nstore, SourceInfo.sample, im+1);
}
if(g_kappa != 0) {
mul_r(temp_save, (2*g_kappa)*(2*g_kappa), temp_save, N);
}
append = !PropInfo.splitted;
construct_writer(&writer, filename, append);
if (PropInfo.splitted || SourceInfo.ix == index_start) {
//Create the inverter info NOTE: always set to TWILSON=12 and 1 flavour (to be adjusted)
inverterInfo = construct_paramsInverterInfo(err, iteration+1, 12, 1);
if (im == -1) {
inverterInfo->cgmms_mass = inverterInfo->mu;
} else {
inverterInfo->cgmms_mass = g_extra_masses[im]/(2 * inverterInfo->kappa);
}
write_spinor_info(writer, PropInfo.format, inverterInfo, append);
//Create the propagatorFormat NOTE: always set to 1 flavour (to be adjusted)
propagatorFormat = construct_paramsPropagatorFormat(cg_mms_default_precision, 1);
write_propagator_format(writer, propagatorFormat);
free(inverterInfo);
free(propagatorFormat);
}
convert_lexic_to_eo(solver_field[2], solver_field[1], temp_save);
write_spinor(writer, &solver_field[2], &solver_field[1], 1, 32);
destruct_writer(writer);
}
finalize_solver(solver_field, nr_sf);
return(iteration+1);
}
/* Compute beta_cg(i+1) = (r(i+1),r(i+1))/(r(i),r(i))
Compute p(i+1) = r(i+1) + beta(i+1)*p(i) */
beta_cg = err/normsq;
assign_mul_add_r(solver_field[2], beta_cg, solver_field[1], N);
normsq = err;
/* Compute betas(i+1) = beta_cg(i)*(zita(i+1)*alphas(i))/(zita(i)*alpha_cg(i))
Compute ps(i+1) = zita(i+1)*r(i+1) + betas(i+1)*ps(i) */
for(im = 0; im < g_no_extra_masses; im++) {
betas[im] = beta_cg*zita[im]*alphas[im]/(zitam1[im]*alpha_cg);
assign_mul_add_mul_r(ps_mms_solver[im], solver_field[1], betas[im], zita[im], N);
}
}
assign(P, solver_field[0], N);
g_sloppy_precision = 0;
finalize_solver(solver_field, nr_sf);
return(-1);
}
/* P output = solution , Q input = source */
int cg_mms_tm(spinor ** const P, spinor * const Q,
solver_params_t * solver_params, double * cgmms_reached_prec) {
static double normsq, pro, err, squarenorm;
int iteration, N = solver_params->sdim, no_shifts = solver_params->no_shifts;
static double gamma, alpham1;
spinor ** solver_field = NULL;
double atime, etime;
const int nr_sf = 3;
atime = gettime();
if(solver_params->sdim == VOLUME) {
init_solver_field(&solver_field, VOLUMEPLUSRAND, nr_sf);
init_mms_tm(no_shifts, VOLUMEPLUSRAND);
}
else {
init_solver_field(&solver_field, VOLUMEPLUSRAND/2, nr_sf);
init_mms_tm(no_shifts, VOLUMEPLUSRAND/2);
}
zero_spinor_field(P[0], N);
alphas[0] = 1.0;
betas[0] = 0.0;
sigma[0] = solver_params->shifts[0]*solver_params->shifts[0];
if(g_proc_id == 0 && g_debug_level > 1) printf("# CGMMS: shift %d is %e\n", 0, sigma[0]);
for(int im = 1; im < no_shifts; im++) {
sigma[im] = solver_params->shifts[im]*solver_params->shifts[im] - sigma[0];
if(g_proc_id == 0 && g_debug_level > 1) printf("# CGMMS: shift %d is %e\n", im, sigma[im]);
// these will be the result spinor fields
zero_spinor_field(P[im], N);
// these are intermediate fields
assign(ps_mms_solver[im-1], Q, N);
zitam1[im] = 1.0;
zita[im] = 1.0;
alphas[im] = 1.0;
betas[im] = 0.0;
}
/* currently only implemented for P=0 */
squarenorm = square_norm(Q, N, 1);
/* if a starting solution vector equal to zero is chosen */
assign(solver_field[0], Q, N);
assign(solver_field[1], Q, N);
normsq = squarenorm;
/* main loop */
for(iteration = 0; iteration < solver_params->max_iter; iteration++) {
/* Q^2*p and then (p,Q^2*p) */
solver_params->M_psi(solver_field[2], solver_field[1]);
// add the zero's shift
assign_add_mul_r(solver_field[2], solver_field[1], sigma[0], N);
pro = scalar_prod_r(solver_field[1], solver_field[2], N, 1);
/* For the update of the coeff. of the shifted pol. we need alphas[0](i-1) and alpha_cg(i).
This is the reason why we need this double definition of alpha */
alpham1 = alphas[0];
/* Compute alphas[0](i+1) */
alphas[0] = normsq/pro;
for(int im = 1; im < no_shifts; im++) {
/* Now gamma is a temp variable that corresponds to zita(i+1) */
gamma = zita[im]*alpham1/(alphas[0]*betas[0]*(1.-zita[im]/zitam1[im])
+ alpham1*(1.+sigma[im]*alphas[0]));
// Now zita(i-1) is put equal to the old zita(i)
zitam1[im] = zita[im];
// Now zita(i+1) is updated
zita[im] = gamma;
// Update of alphas(i) = alphas[0](i)*zita(i+1)/zita(i)
alphas[im] = alphas[0]*zita[im]/zitam1[im];
// Compute xs(i+1) = xs(i) + alphas(i)*ps(i)
assign_add_mul_r(P[im], ps_mms_solver[im-1], alphas[im], N);
// in the CG the corrections are decreasing with the iteration number increasing
// therefore, we can remove shifts when the norm of the correction vector
// falls below a threshold
// this is useful for computing time and needed, because otherwise
// zita might get smaller than DOUBLE_EPS and, hence, zero
if(iteration > 0 && (iteration % 20 == 0) && (im == no_shifts-1)) {
double sn = square_norm(ps_mms_solver[im-1], N, 1);
if(alphas[no_shifts-1]*alphas[no_shifts-1]*sn <= solver_params->squared_solver_prec) {
no_shifts--;
if(g_debug_level > 2 && g_proc_id == 0) {
printf("# CGMMS: at iteration %d removed one shift, %d remaining\n", iteration, no_shifts);
}
}
}
}
/* Compute x_(i+1) = x_i + alphas[0](i+1) p_i */
assign_add_mul_r(P[0], solver_field[1], alphas[0], N);
/* Compute r_(i+1) = r_i - alphas[0](i+1) Qp_i */
assign_add_mul_r(solver_field[0], solver_field[2], -alphas[0], N);
/* Check whether the precision eps_sq is reached */
err = square_norm(solver_field[0], N, 1);
if(g_debug_level > 2 && g_proc_id == g_stdio_proc) {
printf("# CGMMS iteration: %d residue: %g\n", iteration, err); fflush( stdout );
}
if( ((err <= solver_params->squared_solver_prec) && (solver_params->rel_prec == 0)) ||
((err <= solver_params->squared_solver_prec*squarenorm) && (solver_params->rel_prec > 0)) ||
(iteration == solver_params->max_iter -1) ) {
/* FIXME temporary output of precision until a better solution can be found */
*cgmms_reached_prec = err;
break;
}
/* Compute betas[0](i+1) = (r(i+1),r(i+1))/(r(i),r(i))
Compute p(i+1) = r(i+1) + beta(i+1)*p(i) */
betas[0] = err/normsq;
assign_mul_add_r(solver_field[1], betas[0], solver_field[0], N);
normsq = err;
/* Compute betas(i+1) = betas[0](i+1)*(zita(i+1)*alphas(i))/(zita(i)*alphas[0](i))
Compute ps(i+1) = zita(i+1)*r(i+1) + betas(i+1)*ps(i) */
for(int im = 1; im < no_shifts; im++) {
betas[im] = betas[0]*zita[im]*alphas[im]/(zitam1[im]*alphas[0]);
assign_mul_add_mul_r(ps_mms_solver[im-1], solver_field[0], betas[im], zita[im], N);
}
}
etime = gettime();
g_sloppy_precision = 0;
if(iteration == solver_params->max_iter -1) iteration = -1;
else iteration++;
if(g_debug_level > 0 && g_proc_id == 0) {
printf("# CGMMS (%d shifts): iter: %d eps_sq: %1.4e %1.4e t/s\n", solver_params->no_shifts, iteration, solver_params->squared_solver_prec, etime - atime);
}
finalize_solver(solver_field, nr_sf);
return(iteration);
}
