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 cloverdetratio_derivative_orig(const int no, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[no];
/* This factor 2* a missing factor 2 in trace_lambda */
mnl->forcefactor = 1.;
/*********************************************************************
*
* this is being run in case there is even/odd preconditioning
*
* This term is det((Q^2 + \mu_1^2)/(Q^2 + \mu_2^2))
* mu1 and mu2 are set according to the monomial
*
*********************************************************************/
/* First term coming from the second field */
/* Multiply with W_+ */
g_mu = mnl->mu;
g_mu3 = mnl->rho2; //rho2
boundary(mnl->kappa);
// we compute the clover term (1 + T_ee(oo)) for all sites x
sw_term( (const su3**) hf->gaugefield, mnl->kappa, mnl->c_sw);
// we invert it for the even sites only including mu
sw_invert(EE, mnl->mu);
if(mnl->solver != CG) {
fprintf(stderr, "Bicgstab currently not implemented, using CG instead! (detratio_monomial.c)\n");
}
mnl->Qp(g_spinor_field[DUM_DERI+2], mnl->pf);
g_mu3 = mnl->rho; // rho1
/* Invert Q_{+} Q_{-} */
/* X_W -> DUM_DERI+1 */
chrono_guess(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+2], mnl->csg_field,
mnl->csg_index_array, mnl->csg_N, mnl->csg_n, VOLUME/2, mnl->Qsq);
mnl->iter1 += cg_her(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+2], mnl->maxiter,
mnl->forceprec, g_relative_precision_flag, VOLUME/2, mnl->Qsq);
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_W -> DUM_DERI */
mnl->Qm(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
/* apply Hopping Matrix M_{eo} */
/* to get the even sites of X */
H_eo_sw_inv_psi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+1], EE, -mnl->mu);
/* \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, mnl->forcefactor);
/* to get the even sites of Y */
H_eo_sw_inv_psi(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI], EE, mnl->mu);
/* \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, mnl->forcefactor);
// here comes the clover term...
// computes the insertion matrices for S_eff
// result is written to swp and swm
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
gamma5(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+2], VOLUME/2);
sw_spinor(EO, g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3]);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
sw_spinor(OE, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
g_mu3 = mnl->rho2; // rho2
/* Second term coming from the second field */
/* The sign is opposite!! */
mul_r(g_spinor_field[DUM_DERI], -1., mnl->pf, VOLUME/2);
/* apply Hopping Matrix M_{eo} */
/* to get the even sites of X */
H_eo_sw_inv_psi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+1], EE, -mnl->mu);
/* \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, mnl->forcefactor);
/* to get the even sites of Y */
H_eo_sw_inv_psi(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI], EE, mnl->mu);
/* \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, mnl->forcefactor);
// here comes the clover term...
// computes the insertion matrices for S_eff
// result is written to swp and swm
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
gamma5(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+2], VOLUME/2);
sw_spinor(EO, g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3]);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
sw_spinor(OE, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
sw_all(hf, mnl->kappa*mnl->forcefactor, mnl->c_sw);
g_mu = g_mu1;
g_mu3 = 0.;
boundary(g_kappa);
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;
}
void ndpoly_derivative(const int id) {
int j, k;
monomial * mnl = &monomial_list[id];
/* This factor 2 a missing factor 2 in trace_lambda */
(*mnl).forcefactor = -2.*phmc_Cpol*phmc_invmaxev;
/* Recall: The GAMMA_5 left of delta M_eo is done in deriv_Sb !!! */
if (g_epsbar!=0.0 || phmc_exact_poly==0){
/* Here comes the definitions for the chi_j fields */
/* from j=0 (chi_0 = phi) ..... to j = n-1 */
/* in g_chi_up_spinor_field[0] (g_chi_dn_spinor_field[0] we expect */
/* to find the phi field, the pseudo fermion field */
/* i.e. must be equal to mnl->pf (mnl->pf2) */
assign(g_chi_up_spinor_field[0], mnl->pf, VOLUME/2);
assign(g_chi_dn_spinor_field[0], mnl->pf2, VOLUME/2);
for(k = 1; k < (phmc_dop_n_cheby-1); k++) {
Q_tau1_min_cconst_ND(g_chi_up_spinor_field[k], g_chi_dn_spinor_field[k],
g_chi_up_spinor_field[k-1], g_chi_dn_spinor_field[k-1],
phmc_root[k-1]);
}
/* Here comes the remaining fields chi_k ; k=n,...,2n-1 */
/*They are evaluated step-by-step overwriting the same field (phmc_dop_n_cheby)*/
assign(g_chi_up_spinor_field[phmc_dop_n_cheby], g_chi_up_spinor_field[phmc_dop_n_cheby-2], VOLUME/2);
assign(g_chi_dn_spinor_field[phmc_dop_n_cheby], g_chi_dn_spinor_field[phmc_dop_n_cheby-2], VOLUME/2);
for(j=(phmc_dop_n_cheby-1); j>=1; j--) {
assign(g_chi_up_spinor_field[phmc_dop_n_cheby-1], g_chi_up_spinor_field[phmc_dop_n_cheby], VOLUME/2);
assign(g_chi_dn_spinor_field[phmc_dop_n_cheby-1], g_chi_dn_spinor_field[phmc_dop_n_cheby], VOLUME/2);
Q_tau1_min_cconst_ND(g_chi_up_spinor_field[phmc_dop_n_cheby], g_chi_dn_spinor_field[phmc_dop_n_cheby],
g_chi_up_spinor_field[phmc_dop_n_cheby-1], g_chi_dn_spinor_field[phmc_dop_n_cheby-1],
phmc_root[2*phmc_dop_n_cheby-3-j]);
/* Get the even parts of the (j-1)th chi_spinors */
H_eo_ND(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
g_chi_up_spinor_field[j-1], g_chi_dn_spinor_field[j-1], EO);
/* \delta M_eo sandwitched by chi[j-1]_e^\dagger and chi[2N-j]_o */
deriv_Sb(EO, g_spinor_field[DUM_DERI], g_chi_up_spinor_field[phmc_dop_n_cheby]); /* UP */
deriv_Sb(EO, g_spinor_field[DUM_DERI+1], g_chi_dn_spinor_field[phmc_dop_n_cheby]); /* DN */
/* Get the even parts of the (2N-j)-th chi_spinors */
H_eo_ND(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1],
g_chi_up_spinor_field[phmc_dop_n_cheby], g_chi_dn_spinor_field[phmc_dop_n_cheby], EO);
/* \delta M_oe sandwitched by chi[j-1]_o^\dagger and chi[2N-j]_e */
deriv_Sb(OE, g_chi_up_spinor_field[j-1], g_spinor_field[DUM_DERI]);
deriv_Sb(OE, g_chi_dn_spinor_field[j-1], g_spinor_field[DUM_DERI+1]);
}
}
else if(g_epsbar == 0.0) {
/* Here comes the definitions for the chi_j fields */
/* from j=0 (chi_0 = phi) ..... to j = n-1 */
assign(g_chi_up_spinor_field[0], mnl->pf, VOLUME/2);
for(k = 1; k < (phmc_dop_n_cheby-1); k++) {
Qtm_pm_min_cconst_nrm(g_chi_up_spinor_field[k],
g_chi_up_spinor_field[k-1],
phmc_root[k-1]);
}
assign(g_chi_up_spinor_field[phmc_dop_n_cheby],
g_chi_up_spinor_field[phmc_dop_n_cheby-2], VOLUME/2);
for(j = (phmc_dop_n_cheby-1); j >= 1; j--) {
assign(g_chi_up_spinor_field[phmc_dop_n_cheby-1],
g_chi_up_spinor_field[phmc_dop_n_cheby], VOLUME/2);
Qtm_pm_min_cconst_nrm(g_chi_up_spinor_field[phmc_dop_n_cheby],
g_chi_up_spinor_field[phmc_dop_n_cheby-1],
phmc_root[2*phmc_dop_n_cheby-3-j]);
Qtm_minus_psi(g_spinor_field[DUM_DERI+3],g_chi_up_spinor_field[j-1]);
H_eo_tm_inv_psi(g_spinor_field[DUM_DERI+2], g_chi_up_spinor_field[phmc_dop_n_cheby], EO, -1.);
deriv_Sb(OE, g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+2]);
H_eo_tm_inv_psi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3], EO, 1.);
deriv_Sb(EO, g_spinor_field[DUM_DERI+2], g_chi_up_spinor_field[phmc_dop_n_cheby]);
Qtm_minus_psi(g_spinor_field[DUM_DERI+3],g_chi_up_spinor_field[phmc_dop_n_cheby]);
H_eo_tm_inv_psi(g_spinor_field[DUM_DERI+2],g_spinor_field[DUM_DERI+3], EO, +1.);
deriv_Sb(OE, g_chi_up_spinor_field[j-1] , g_spinor_field[DUM_DERI+2]);
H_eo_tm_inv_psi(g_spinor_field[DUM_DERI+2], g_chi_up_spinor_field[j-1], EO, -1.);
deriv_Sb(EO, g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3]);
}
}
/*
Normalisation by the largest EW is done in update_momenta
using mnl->forcefactor
*/
}
void cloverdet_derivative(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
double atime, etime;
int N = VOLUME/2;
atime = gettime();
for(int i = 0; i < VOLUME; i++) {
for(int mu = 0; mu < 4; mu++) {
_su3_zero(swm[i][mu]);
_su3_zero(swp[i][mu]);
}
}
mnl->forcefactor = 1.;
/*********************************************************************
*
*
* This a term is det(\hat Q^2(\mu))
*
*********************************************************************/
g_mu = mnl->mu;
g_mu3 = mnl->rho;
boundary(mnl->kappa);
// we compute the clover term (1 + T_ee(oo)) for all sites x
sw_term( (const su3**) hf->gaugefield, mnl->kappa, mnl->c_sw);
// we invert it for the even sites only
if(!mnl->even_odd_flag) {
N = VOLUME;
}
else {
sw_invert(EE, mnl->mu);
}
if(mnl->solver != CG && g_proc_id == 0) {
fprintf(stderr, "Bicgstab currently not implemented, using CG instead! (cloverdet_monomial.c)\n");
}
// 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);
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, N);
// Y_o -> w_fields[0]
mnl->Qm(mnl->w_fields[0], mnl->w_fields[1]);
if(mnl->even_odd_flag) {
// apply Hopping Matrix M_{eo}
// to get the even sites of X_e
H_eo_sw_inv_psi(mnl->w_fields[2], mnl->w_fields[1], EO, -1, mnl->mu);
// \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_sw_inv_psi(mnl->w_fields[3], mnl->w_fields[0], EO, +1, mnl->mu);
// \delta Q sandwitched by Y_e^\dagger and X_o
// uses the gauge field in hf and changes the derivative fields in hf
deriv_Sb(EO, mnl->w_fields[3], mnl->w_fields[1], hf, mnl->forcefactor);
// here comes the clover term...
// computes the insertion matrices for S_eff
// result is written to swp and swm
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
sw_spinor_eo(EE, mnl->w_fields[2], mnl->w_fields[3], mnl->forcefactor);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
sw_spinor_eo(OO, mnl->w_fields[0], mnl->w_fields[1], mnl->forcefactor);
// compute the contribution for the det-part
// we again compute only the insertion matrices for S_det
// the result is added to swp and swm
// even sites only!
sw_deriv(EE, mnl->mu);
}
else {
/* \delta Q sandwitched by Y^\dagger and X */
deriv_Sb_D_psi(mnl->w_fields[0], mnl->w_fields[1], hf, mnl->forcefactor);
sw_spinor(mnl->w_fields[0], mnl->w_fields[1], mnl->forcefactor);
}
// now we compute
// finally, using the insertion matrices stored in swm and swp
// we compute the terms F^{det} and F^{sw} at once
// uses the gaugefields in hf and changes the derivative field in hf
sw_all(hf, mnl->kappa, mnl->c_sw);
g_mu = g_mu1;
g_mu3 = 0.;
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 rat_derivative(const int id, hamiltonian_field_t * const hf) {
monomial * mnl = &monomial_list[id];
solver_pm_t solver_pm;
double atime, etime, dummy;
atime = gettime();
g_mu = 0;
g_mu3 = 0.;
boundary(mnl->kappa);
if(mnl->type == CLOVERRAT) {
g_c_sw = mnl->c_sw;
for(int i = 0; i < VOLUME; i++) {
for(int mu = 0; mu < 4; mu++) {
_su3_zero(swm[i][mu]);
_su3_zero(swp[i][mu]);
}
}
// we compute the clover term (1 + T_ee(oo)) for all sites x
sw_term( (const su3**) hf->gaugefield, mnl->kappa, mnl->c_sw);
// we invert it for the even sites only
sw_invert(EE, 0.);
}
//mnl->forcefactor = mnl->EVMaxInv*mnl->EVMaxInv;
mnl->forcefactor = 1.;
solver_pm.max_iter = mnl->maxiter;
solver_pm.squared_solver_prec = mnl->forceprec;
solver_pm.no_shifts = mnl->rat.np;
solver_pm.shifts = mnl->rat.mu;
solver_pm.rel_prec = g_relative_precision_flag;
solver_pm.type = CGMMS;
solver_pm.M_psi = mnl->Qsq;
solver_pm.sdim = VOLUME/2;
// this generates all X_j,o (odd sites only) -> g_chi_up_spinor_field
mnl->iter1 += cg_mms_tm(g_chi_up_spinor_field, mnl->pf,
&solver_pm, &dummy);
for(int j = (mnl->rat.np-1); j > -1; j--) {
mnl->Qp(mnl->w_fields[0], g_chi_up_spinor_field[j]);
if(mnl->type == CLOVERRAT) {
// apply Hopping Matrix M_{eo}
// to get the even sites of X_e
H_eo_sw_inv_psi(mnl->w_fields[2], g_chi_up_spinor_field[j], EO, -1, mnl->mu);
// \delta Q sandwitched by Y_o^\dagger and X_e
deriv_Sb(OE, mnl->w_fields[0], mnl->w_fields[2], hf,
mnl->rat.rmu[j]*mnl->forcefactor);
// to get the even sites of Y_e
H_eo_sw_inv_psi(mnl->w_fields[3], mnl->w_fields[0], EO, +1, mnl->mu);
// \delta Q sandwitched by Y_e^\dagger and X_o
// uses the gauge field in hf and changes the derivative fields in hf
deriv_Sb(EO, mnl->w_fields[3], g_chi_up_spinor_field[j], hf,
mnl->rat.rmu[j]*mnl->forcefactor);
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
sw_spinor(EE, mnl->w_fields[2], mnl->w_fields[3], mnl->rat.rmu[j]*mnl->forcefactor);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
sw_spinor(OO, mnl->w_fields[0], g_chi_up_spinor_field[j], mnl->rat.rmu[j]*mnl->forcefactor);
}
else {
/* apply Hopping Matrix M_{eo} */
/* to get the even sites of X_e */
H_eo_tm_inv_psi(mnl->w_fields[2], g_chi_up_spinor_field[j], 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->rat.rmu[j]*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], g_chi_up_spinor_field[j], hf,
mnl->rat.rmu[j]*mnl->forcefactor);
}
}
if(mnl->type == CLOVERRAT && mnl->trlog) {
sw_deriv(EE, 0.);
}
if(mnl->type == CLOVERRAT) {
sw_all(hf, mnl->kappa, mnl->c_sw);
}
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 cloverndpoly_derivative(const int id, hamiltonian_field_t * const hf) {
int j, k;
monomial * mnl = &monomial_list[id];
double atime, etime;
atime = gettime();
for(int i = 0; i < VOLUME; i++) {
for(int mu = 0; mu < 4; mu++) {
_su3_zero(swm[i][mu]);
_su3_zero(swp[i][mu]);
}
}
ndpoly_set_global_parameter(mnl, 0);
// we compute the clover term (1 + T_ee(oo)) for all sites x
sw_term( (const su3**) hf->gaugefield, mnl->kappa, mnl->c_sw);
// we invert it for the even sites only
sw_invert_nd(mnl->mubar*mnl->mubar - mnl->epsbar*mnl->epsbar);
mnl->forcefactor = -phmc_Cpol*mnl->EVMaxInv;
/* Recall: The GAMMA_5 left of delta M_eo is done in deriv_Sb !!! */
/* Here comes the definitions for the chi_j fields */
/* from j=0 (chi_0 = phi) ..... to j = n-1 */
/* in g_chi_up_spinor_field[0] (g_chi_dn_spinor_field[0] we expect */
/* to find the phi field, the pseudo fermion field */
/* i.e. must be equal to mnl->pf (mnl->pf2) */
assign(g_chi_up_spinor_field[0], mnl->pf, VOLUME/2);
assign(g_chi_dn_spinor_field[0], mnl->pf2, VOLUME/2);
for(k = 1; k < (mnl->MDPolyDegree-1); k++) {
Qsw_tau1_sub_const_ndpsi(g_chi_up_spinor_field[k], g_chi_dn_spinor_field[k],
g_chi_up_spinor_field[k-1], g_chi_dn_spinor_field[k-1],
mnl->MDPolyRoots[k-1]);
}
/* Here comes the remaining fields chi_k ; k=n,...,2n-1 */
/*They are evaluated step-by-step overwriting the same field (mnl->MDPolyDegree)*/
assign(g_chi_up_spinor_field[mnl->MDPolyDegree], g_chi_up_spinor_field[mnl->MDPolyDegree-2], VOLUME/2);
assign(g_chi_dn_spinor_field[mnl->MDPolyDegree], g_chi_dn_spinor_field[mnl->MDPolyDegree-2], VOLUME/2);
for(j = (mnl->MDPolyDegree-1); j > 0; j--) {
assign(g_chi_up_spinor_field[mnl->MDPolyDegree-1], g_chi_up_spinor_field[mnl->MDPolyDegree], VOLUME/2);
assign(g_chi_dn_spinor_field[mnl->MDPolyDegree-1], g_chi_dn_spinor_field[mnl->MDPolyDegree], VOLUME/2);
Qsw_tau1_sub_const_ndpsi(g_chi_up_spinor_field[mnl->MDPolyDegree], g_chi_dn_spinor_field[mnl->MDPolyDegree],
g_chi_up_spinor_field[mnl->MDPolyDegree-1], g_chi_dn_spinor_field[mnl->MDPolyDegree-1],
mnl->MDPolyRoots[2*mnl->MDPolyDegree-3-j]);
/* Get the even parts of the (j-1)th chi_spinors */
H_eo_sw_ndpsi(mnl->w_fields[0], mnl->w_fields[1],
g_chi_up_spinor_field[j-1], g_chi_dn_spinor_field[j-1]);
/* \delta M_eo sandwitched by chi[j-1]_e^\dagger and chi[2N-j]_o */
deriv_Sb(EO, mnl->w_fields[0], g_chi_up_spinor_field[mnl->MDPolyDegree], hf, mnl->forcefactor);/* UP */
deriv_Sb(EO, mnl->w_fields[1], g_chi_dn_spinor_field[mnl->MDPolyDegree], hf, mnl->forcefactor);/* DN */
/* Get the even parts of the (2N-j)-th chi_spinors */
H_eo_sw_ndpsi(mnl->w_fields[2], mnl->w_fields[3],
g_chi_up_spinor_field[mnl->MDPolyDegree], g_chi_dn_spinor_field[mnl->MDPolyDegree]);
/* \delta M_oe sandwitched by chi[j-1]_o^\dagger and chi[2N-j]_e */
deriv_Sb(OE, g_chi_up_spinor_field[j-1], mnl->w_fields[2], hf, mnl->forcefactor);
deriv_Sb(OE, g_chi_dn_spinor_field[j-1], mnl->w_fields[3], hf, mnl->forcefactor);
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
sw_spinor(EE, mnl->w_fields[3], mnl->w_fields[0], mnl->forcefactor);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
sw_spinor(OO, g_chi_up_spinor_field[j-1], g_chi_dn_spinor_field[mnl->MDPolyDegree], mnl->forcefactor);
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
sw_spinor(EE, mnl->w_fields[2], mnl->w_fields[1], mnl->forcefactor);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
sw_spinor(OO, g_chi_dn_spinor_field[j-1], g_chi_up_spinor_field[mnl->MDPolyDegree], mnl->forcefactor);
}
// trlog part does not depend on the normalisation of the polynomial
sw_deriv_nd(EE);
sw_all(hf, mnl->kappa, mnl->c_sw);
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 cloverdet_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.;
/*********************************************************************
*
* even/odd version
*
* This a term is det(\hat Q^2(\mu))
*
*********************************************************************/
g_mu = mnl->mu;
g_mu3 = mnl->rho;
boundary(mnl->kappa);
// we compute the clover term (1 + T_ee(oo)) for all sites x
sw_term(hf->gaugefield, mnl->kappa, mnl->c_sw);
// we invert it for the even sites only
sw_invert(EE, mnl->mu);
if(mnl->solver != CG && g_proc_id == 0) {
fprintf(stderr, "Bicgstab currently not implemented, using CG instead! (cloverdet_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, mnl->Qsq);
mnl->iter1 += cg_her(g_spinor_field[DUM_DERI+1], mnl->pf, mnl->maxiter, mnl->forceprec,
g_relative_precision_flag, VOLUME/2, mnl->Qsq);
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
mnl->Qm(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_sw_inv_psi(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+1], EE, -mnl->mu);
// \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_sw_inv_psi(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI], EE, mnl->mu);
// \delta Q sandwitched by Y_e^\dagger and X_o
// uses the gauge field in hf and changes the derivative fields in hf
deriv_Sb(EO, g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+1], hf);
// here comes the clover term...
// computes the insertion matrices for S_eff
// result is written to swp and swm
// even/even sites sandwiched by gamma_5 Y_e and gamma_5 X_e
gamma5(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+2], VOLUME/2);
sw_spinor(EO, g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+3]);
// odd/odd sites sandwiched by gamma_5 Y_o and gamma_5 X_o
gamma5(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI], VOLUME/2);
sw_spinor(OE, g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+1]);
// compute the contribution for the det-part
// we again compute only the insertion matrices for S_det
// the result is added to swp and swm
// even sites only!
sw_deriv(EE, mnl->mu);
// now we compute
// finally, using the insertion matrices stored in swm and swp
// we compute the terms F^{det} and F^{sw} at once
// uses the gaugefields in hf and changes the derivative field in hf
sw_all(hf, mnl->kappa, mnl->c_sw);
g_mu = g_mu1;
g_mu3 = 0.;
boundary(g_kappa);
return;
}
