double det_acc(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
int save_sloppy = g_sloppy_precision_flag;
double atime, etime;
atime = gettime();
g_mu = mnl->mu;
boundary(mnl->kappa);
if(mnl->even_odd_flag) {
chrono_guess(mnl->w_fields[0], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, mnl->Qsq);
g_sloppy_precision_flag = 0;
mnl->iter0 += solve_degenerate(mnl->w_fields[0], mnl->pf, mnl->solver_params, mnl->maxiter,
mnl->accprec, g_relative_precision_flag,VOLUME/2, mnl->Qsq, mnl->solver);
mnl->Qm(mnl->w_fields[1], mnl->w_fields[0]);
g_sloppy_precision_flag = save_sloppy;
/* Compute the energy contr. from first field */
mnl->energy1 = square_norm(mnl->w_fields[1], VOLUME/2, 1);
}
else {
if((mnl->solver == CG) || (mnl->solver == MIXEDCG)) {
chrono_guess(mnl->w_fields[1], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_pm_psi);
mnl->iter0 += solve_degenerate(mnl->w_fields[1], mnl->pf, mnl->solver_params, mnl->maxiter,
mnl->accprec, g_relative_precision_flag,
VOLUME, &Q_pm_psi, mnl->solver);
Q_minus_psi(mnl->w_fields[0], mnl->w_fields[1]);
/* Compute the energy contr. from first field */
mnl->energy1 = square_norm(mnl->w_fields[0], VOLUME, 1);
}
else {
chrono_guess(mnl->w_fields[0], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_plus_psi);
mnl->iter0 += solve_degenerate(mnl->w_fields[0], mnl->pf, mnl->solver_params,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, &Q_plus_psi, mnl->solver);
mnl->energy1 = square_norm(mnl->w_fields[0], VOLUME, 1);
}
}
g_mu = g_mu1;
boundary(g_kappa);
etime = gettime();
if(g_proc_id == 0) {
if(g_debug_level > 1) {
printf("# Time for %s monomial acc step: %e s\n", mnl->name, etime-atime);
}
if(g_debug_level > 3) {
printf("called det_acc for id %d dH = %1.10e\n",
id, mnl->energy1 - mnl->energy0);
}
}
return(mnl->energy1 - mnl->energy0);
}
double det_acc(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
int save_iter = ITER_MAX_BCG;
int save_sloppy = g_sloppy_precision_flag;
g_mu = mnl->mu;
boundary(mnl->kappa);
if(mnl->even_odd_flag) {
if(mnl->solver == CG) {
ITER_MAX_BCG = 0;
}
chrono_guess(g_spinor_field[2], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Qtm_plus_psi);
g_sloppy_precision_flag = 0;
mnl->iter0 = bicg(g_spinor_field[2], mnl->pf, mnl->accprec, g_relative_precision_flag);
g_sloppy_precision_flag = save_sloppy;
/* Compute the energy contr. from first field */
mnl->energy1 = square_norm(g_spinor_field[2], VOLUME/2, 1);
}
else {
if(mnl->solver == CG) {
chrono_guess(g_spinor_field[DUM_DERI+5], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_pm_psi);
mnl->iter0 = cg_her(g_spinor_field[DUM_DERI+5], mnl->pf,
mnl->maxiter, mnl->accprec, g_relative_precision_flag,
VOLUME, Q_pm_psi);
Q_minus_psi(g_spinor_field[2], g_spinor_field[DUM_DERI+5]);
/* Compute the energy contr. from first field */
mnl->energy1 = square_norm(g_spinor_field[2], VOLUME, 1);
}
else {
chrono_guess(g_spinor_field[2], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_plus_psi);
mnl->iter0 += bicgstab_complex(g_spinor_field[2], mnl->pf,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, Q_plus_psi);
mnl->energy1 = square_norm(g_spinor_field[2], VOLUME, 1);
}
}
g_mu = g_mu1;
boundary(g_kappa);
if(g_proc_id == 0 && g_debug_level > 3) {
printf("called det_acc for id %d %d dH = %1.4e\n",
id, mnl->even_odd_flag, mnl->energy1 - mnl->energy0);
}
ITER_MAX_BCG = save_iter;
return(mnl->energy1 - mnl->energy0);
}
void det_derivative(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
double atime, etime;
atime = gettime();
mnl->forcefactor = 1.;
if(mnl->even_odd_flag) {
/*********************************************************************
*
* even/odd version
*
* This a term is det(\hat Q^2(\mu))
*
*********************************************************************/
g_mu = mnl->mu;
boundary(mnl->kappa);
/* Invert Q_{+} Q_{-} */
/* X_o -> w_fields[1] */
chrono_guess(mnl->w_fields[1], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, mnl->Qsq);
if(mnl->solver==BICGSTAB)
{
fprintf(stderr, "Bicgstab currently not implemented, using CG instead! (det_monomial.c)\n");
mnl->iter1 += solve_degenerate(mnl->w_fields[1], mnl->pf, mnl->solver_params, mnl->maxiter, mnl->forceprec,
g_relative_precision_flag, VOLUME/2, mnl->Qsq, CG);
}
else{
mnl->iter1 += solve_degenerate(mnl->w_fields[1], mnl->pf, mnl->solver_params, mnl->maxiter, mnl->forceprec,
g_relative_precision_flag, VOLUME/2, mnl->Qsq, mnl->solver);
}
chrono_add_solution(mnl->w_fields[1], mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, &mnl->csg_n, VOLUME/2);
/* Y_o -> w_fields[0] */
mnl->Qm(mnl->w_fields[0], mnl->w_fields[1]);
/* apply Hopping Matrix M_{eo} */
/* to get the even sites of X_e */
H_eo_tm_inv_psi(mnl->w_fields[2], mnl->w_fields[1], EO, -1.);
/* \delta Q sandwitched by Y_o^\dagger and X_e */
deriv_Sb(OE, mnl->w_fields[0], mnl->w_fields[2], hf, mnl->forcefactor);
/* to get the even sites of Y_e */
H_eo_tm_inv_psi(mnl->w_fields[3], mnl->w_fields[0], EO, +1);
/* \delta Q sandwitched by Y_e^\dagger and X_o */
deriv_Sb(EO, mnl->w_fields[3], mnl->w_fields[1], hf, mnl->forcefactor);
}
else {
/*********************************************************************
* non even/odd version
*
* This term is det(Q^2 + \mu_1^2)
*
*********************************************************************/
g_mu = mnl->mu;
boundary(mnl->kappa);
if((mnl->solver == CG) || (mnl->solver == MIXEDCG) || (mnl->solver == RGMIXEDCG)) {
/* Invert Q_{+} Q_{-} */
/* X -> w_fields[1] */
chrono_guess(mnl->w_fields[1], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_pm_psi);
mnl->iter1 += solve_degenerate(mnl->w_fields[1], mnl->pf, mnl->solver_params,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, &Q_pm_psi, mnl->solver);
chrono_add_solution(mnl->w_fields[1], mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, &mnl->csg_n, VOLUME/2);
/* Y -> w_fields[0] */
Q_minus_psi(mnl->w_fields[0], mnl->w_fields[1]);
}
else {
/* Invert first Q_+ */
/* Y -> w_fields[0] */
chrono_guess(mnl->w_fields[0], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_plus_psi);
mnl->iter1 += solve_degenerate(mnl->w_fields[0], mnl->pf, mnl->solver_params,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, &Q_plus_psi, mnl->solver);
chrono_add_solution(mnl->w_fields[0], mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, &mnl->csg_n, VOLUME/2);
/* Now Q_- */
/* X -> w_fields[1] */
chrono_guess(mnl->w_fields[1], mnl->w_fields[0], mnl->csg_field2,
mnl->csg_index_array2, mnl->csg_N2, mnl->csg_n2, VOLUME/2, &Q_minus_psi);
mnl->iter1 += solve_degenerate(mnl->w_fields[1], mnl->w_fields[0], mnl->solver_params,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, &Q_minus_psi, mnl->solver);
chrono_add_solution(mnl->w_fields[1], mnl->csg_field2, mnl->csg_index_array2,
mnl->csg_N2, &mnl->csg_n2, VOLUME/2);
}
/* \delta Q sandwitched by Y^\dagger and X */
deriv_Sb_D_psi(mnl->w_fields[0], mnl->w_fields[1], hf, mnl->forcefactor);
}
g_mu = g_mu1;
boundary(g_kappa);
etime = gettime();
if(g_debug_level > 1 && g_proc_id == 0) {
printf("# Time for %s monomial derivative: %e s\n", mnl->name, etime-atime);
}
return;
}
void det_derivative(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
/* This factor 2 a missing factor 2 in trace_lambda */
(*mnl).forcefactor = 2.;
if(mnl->even_odd_flag) {
/*********************************************************************
*
* even/odd version
*
* This a term is det(\hat Q^2(\mu))
*
*********************************************************************/
g_mu = mnl->mu;
boundary(mnl->kappa);
if(mnl->solver != CG) {
fprintf(stderr, "Bicgstab currently not implemented, using CG instead! (det_monomial.c)\n");
}
/* Invert Q_{+} Q_{-} */
/* X_o -> DUM_DERI+1 */
chrono_guess(g_spinor_field[DUM_DERI+1], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Qtm_pm_psi);
mnl->iter1 += cg_her(g_spinor_field[DUM_DERI+1], mnl->pf, mnl->maxiter, mnl->forceprec,
g_relative_precision_flag, VOLUME/2, &Qtm_pm_psi);
chrono_add_solution(g_spinor_field[DUM_DERI+1], mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, &mnl->csg_n, VOLUME/2);
/* Y_o -> DUM_DERI */
Qtm_minus_psi(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
/* apply Hopping Matrix M_{eo} */
/* to get the even sites of X_e */
H_eo_tm_inv_psi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+1], EO, -1.);
/* \delta Q sandwitched by Y_o^\dagger and X_e */
deriv_Sb(OE, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+2], hf);
/* to get the even sites of Y_e */
H_eo_tm_inv_psi(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI], EO, +1);
/* \delta Q sandwitched by Y_e^\dagger and X_o */
deriv_Sb(EO, g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+1], hf);
}
else {
/*********************************************************************
* non even/odd version
*
* This term is det(Q^2 + \mu_1^2)
*
*********************************************************************/
g_mu = mnl->mu;
boundary(mnl->kappa);
if(mnl->solver == CG) {
/* Invert Q_{+} Q_{-} */
/* X -> DUM_DERI+1 */
chrono_guess(g_spinor_field[DUM_DERI+1], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_pm_psi);
mnl->iter1 += cg_her(g_spinor_field[DUM_DERI+1], mnl->pf,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, &Q_pm_psi);
chrono_add_solution(g_spinor_field[DUM_DERI+1], mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, &mnl->csg_n, VOLUME/2);
/* Y -> DUM_DERI */
Q_minus_psi(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
}
else {
/* Invert first Q_+ */
/* Y -> DUM_DERI */
chrono_guess(g_spinor_field[DUM_DERI], mnl->pf, mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, mnl->csg_n, VOLUME/2, &Q_plus_psi);
mnl->iter1 += bicgstab_complex(g_spinor_field[DUM_DERI], mnl->pf,
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, Q_plus_psi);
chrono_add_solution(g_spinor_field[DUM_DERI], mnl->csg_field, mnl->csg_index_array,
mnl->csg_N, &mnl->csg_n, VOLUME/2);
/* Now Q_- */
/* X -> DUM_DERI+1 */
g_mu = -g_mu;
chrono_guess(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI], mnl->csg_field2,
mnl->csg_index_array2, mnl->csg_N2, mnl->csg_n2, VOLUME/2, &Q_minus_psi);
mnl->iter1 += bicgstab_complex(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI],
mnl->maxiter, mnl->forceprec, g_relative_precision_flag,
VOLUME, Q_minus_psi);
chrono_add_solution(g_spinor_field[DUM_DERI+1], mnl->csg_field2, mnl->csg_index_array2,
mnl->csg_N2, &mnl->csg_n2, VOLUME/2);
g_mu = -g_mu;
}
/* \delta Q sandwitched by Y^\dagger and X */
deriv_Sb_D_psi(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1], hf);
}
g_mu = g_mu1;
boundary(g_kappa);
return;
}
