void op_invert(const int op_id, const int index_start, const int write_prop) {
operator * optr = &operator_list[op_id];
double atime = 0., etime = 0., nrm1 = 0., nrm2 = 0.;
int i;
optr->iterations = 0;
optr->reached_prec = -1.;
g_kappa = optr->kappa;
boundary(g_kappa);
atime = gettime();
if(optr->type == TMWILSON || optr->type == WILSON || optr->type == CLOVER) {
g_mu = optr->mu;
g_c_sw = optr->c_sw;
if(optr->type == CLOVER) {
if (g_cart_id == 0 && g_debug_level > 1) {
printf("#\n# csw = %e, computing clover leafs\n", g_c_sw);
}
init_sw_fields(VOLUME);
sw_term( (const su3**) g_gauge_field, optr->kappa, optr->c_sw);
/* this must be EE here! */
/* to match clover_inv in Qsw_psi */
sw_invert(EE, optr->mu);
}
for(i = 0; i < 2; i++) {
if (g_cart_id == 0) {
printf("#\n# 2 kappa mu = %e, kappa = %e, c_sw = %e\n", g_mu, g_kappa, g_c_sw);
}
if(optr->type != CLOVER) {
if(use_preconditioning){
g_precWS=(void*)optr->precWS;
}
else {
g_precWS=NULL;
}
optr->iterations = invert_eo( optr->prop0, optr->prop1, optr->sr0, optr->sr1,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec,
0, optr->even_odd_flag,optr->no_extra_masses, optr->extra_masses, optr->id );
/* check result */
M_full(g_spinor_field[4], g_spinor_field[5], optr->prop0, optr->prop1);
}
else {
optr->iterations = invert_clover_eo(optr->prop0, optr->prop1, optr->sr0, optr->sr1,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec,
&g_gauge_field, &Qsw_pm_psi, &Qsw_minus_psi);
/* check result */
Msw_full(g_spinor_field[4], g_spinor_field[5], optr->prop0, optr->prop1);
}
diff(g_spinor_field[4], g_spinor_field[4], optr->sr0, VOLUME / 2);
diff(g_spinor_field[5], g_spinor_field[5], optr->sr1, VOLUME / 2);
nrm1 = square_norm(g_spinor_field[4], VOLUME / 2, 1);
nrm2 = square_norm(g_spinor_field[5], VOLUME / 2, 1);
optr->reached_prec = nrm1 + nrm2;
/* convert to standard normalisation */
/* we have to mult. by 2*kappa */
if (optr->kappa != 0.) {
mul_r(optr->prop0, (2*optr->kappa), optr->prop0, VOLUME / 2);
mul_r(optr->prop1, (2*optr->kappa), optr->prop1, VOLUME / 2);
}
if (optr->solver != CGMMS && write_prop) /* CGMMS handles its own I/O */
optr->write_prop(op_id, index_start, i);
if(optr->DownProp) {
optr->mu = -optr->mu;
} else
break;
}
}
else if(optr->type == DBTMWILSON || optr->type == DBCLOVER) {
g_mubar = optr->mubar;
g_epsbar = optr->epsbar;
g_c_sw = 0.;
if(optr->type == DBCLOVER) {
g_c_sw = optr->c_sw;
if (g_cart_id == 0 && g_debug_level > 1) {
printf("#\n# csw = %e, computing clover leafs\n", g_c_sw);
}
init_sw_fields(VOLUME);
sw_term( (const su3**) g_gauge_field, optr->kappa, optr->c_sw);
sw_invert_nd(optr->mubar*optr->mubar-optr->epsbar*optr->epsbar);
}
for(i = 0; i < SourceInfo.no_flavours; i++) {
if(optr->type != DBCLOVER) {
optr->iterations = invert_doublet_eo( optr->prop0, optr->prop1, optr->prop2, optr->prop3,
optr->sr0, optr->sr1, optr->sr2, optr->sr3,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec);
}
else {
optr->iterations = invert_cloverdoublet_eo( optr->prop0, optr->prop1, optr->prop2, optr->prop3,
optr->sr0, optr->sr1, optr->sr2, optr->sr3,
optr->eps_sq, optr->maxiter,
optr->solver, optr->rel_prec);
}
g_mu = optr->mubar;
if(optr->type != DBCLOVER) {
M_full(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+2], optr->prop0, optr->prop1);
}
else {
Msw_full(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+2], optr->prop0, optr->prop1);
}
assign_add_mul_r(g_spinor_field[DUM_DERI+1], optr->prop2, -optr->epsbar, VOLUME/2);
assign_add_mul_r(g_spinor_field[DUM_DERI+2], optr->prop3, -optr->epsbar, VOLUME/2);
g_mu = -g_mu;
if(optr->type != DBCLOVER) {
M_full(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+4], optr->prop2, optr->prop3);
}
else {
Msw_full(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+4], optr->prop2, optr->prop3);
}
assign_add_mul_r(g_spinor_field[DUM_DERI+3], optr->prop0, -optr->epsbar, VOLUME/2);
assign_add_mul_r(g_spinor_field[DUM_DERI+4], optr->prop1, -optr->epsbar, VOLUME/2);
diff(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+1], optr->sr0, VOLUME/2);
diff(g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI+2], optr->sr1, VOLUME/2);
diff(g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+3], optr->sr2, VOLUME/2);
diff(g_spinor_field[DUM_DERI+4], g_spinor_field[DUM_DERI+4], optr->sr3, VOLUME/2);
nrm1 = square_norm(g_spinor_field[DUM_DERI+1], VOLUME/2, 1);
nrm1 += square_norm(g_spinor_field[DUM_DERI+2], VOLUME/2, 1);
nrm1 += square_norm(g_spinor_field[DUM_DERI+3], VOLUME/2, 1);
nrm1 += square_norm(g_spinor_field[DUM_DERI+4], VOLUME/2, 1);
optr->reached_prec = nrm1;
g_mu = g_mu1;
/* For standard normalisation */
/* we have to mult. by 2*kappa */
mul_r(g_spinor_field[DUM_DERI], (2*optr->kappa), optr->prop0, VOLUME/2);
mul_r(g_spinor_field[DUM_DERI+1], (2*optr->kappa), optr->prop1, VOLUME/2);
mul_r(g_spinor_field[DUM_DERI+2], (2*optr->kappa), optr->prop2, VOLUME/2);
mul_r(g_spinor_field[DUM_DERI+3], (2*optr->kappa), optr->prop3, VOLUME/2);
/* the final result should be stored in the convention used in */
/* hep-lat/0606011 */
/* this requires multiplication of source with */
/* (1+itau_2)/sqrt(2) and the result with (1-itau_2)/sqrt(2) */
mul_one_pm_itau2(optr->prop0, optr->prop2, g_spinor_field[DUM_DERI],
g_spinor_field[DUM_DERI+2], -1., VOLUME/2);
mul_one_pm_itau2(optr->prop1, optr->prop3, g_spinor_field[DUM_DERI+1],
g_spinor_field[DUM_DERI+3], -1., VOLUME/2);
/* write propagator */
if(write_prop) optr->write_prop(op_id, index_start, i);
mul_r(optr->prop0, 1./(2*optr->kappa), g_spinor_field[DUM_DERI], VOLUME/2);
mul_r(optr->prop1, 1./(2*optr->kappa), g_spinor_field[DUM_DERI+1], VOLUME/2);
mul_r(optr->prop2, 1./(2*optr->kappa), g_spinor_field[DUM_DERI+2], VOLUME/2);
mul_r(optr->prop3, 1./(2*optr->kappa), g_spinor_field[DUM_DERI+3], VOLUME/2);
/* mirror source, but not for volume sources */
if(i == 0 && SourceInfo.no_flavours == 2 && SourceInfo.type != 1) {
if (g_cart_id == 0) {
fprintf(stdout, "# Inversion done in %d iterations, squared residue = %e!\n",
optr->iterations, optr->reached_prec);
}
mul_one_pm_itau2(g_spinor_field[DUM_DERI], g_spinor_field[DUM_DERI+2], optr->sr0, optr->sr2, -1., VOLUME/2);
mul_one_pm_itau2(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI+3], optr->sr1, optr->sr3, -1., VOLUME/2);
mul_one_pm_itau2(optr->sr0, optr->sr2, g_spinor_field[DUM_DERI+2], g_spinor_field[DUM_DERI], +1., VOLUME/2);
mul_one_pm_itau2(optr->sr1, optr->sr3, g_spinor_field[DUM_DERI+3], g_spinor_field[DUM_DERI+1], +1., VOLUME/2);
}
/* volume sources need only one inversion */
else if(SourceInfo.type == 1) i++;
}
}
else if(optr->type == OVERLAP) {
g_mu = 0.;
m_ov=optr->m;
eigenvalues(&optr->no_ev, 5000, optr->ev_prec, 0, optr->ev_readwrite, nstore, optr->even_odd_flag);
/* ov_check_locality(); */
/* index_jd(&optr->no_ev_index, 5000, 1.e-12, optr->conf_input, nstore, 4); */
ov_n_cheby=optr->deg_poly;
if(use_preconditioning==1)
g_precWS=(void*)optr->precWS;
else
g_precWS=NULL;
if(g_debug_level > 3) ov_check_ginsparg_wilson_relation_strong();
invert_overlap(op_id, index_start);
if(write_prop) optr->write_prop(op_id, index_start, 0);
}
etime = gettime();
if (g_cart_id == 0 && g_debug_level > 0) {
fprintf(stdout, "# Inversion done in %d iterations, squared residue = %e!\n",
optr->iterations, optr->reached_prec);
fprintf(stdout, "# Inversion done in %1.2e sec. \n", etime - atime);
}
return;
}
void pion_norm(const int traj, const int id) {
int i, j, z, zz, z0;
double *Cpp;
double res = 0.;
double pionnorm;
double atime, etime;
float tmp;
#ifdef MPI
double mpi_res = 0.;
#endif
FILE *ofs, *ofs2;
char *filename, *filename2, *sourcefilename;
char buf[100];
char buf2[100];
char buf3[100];
filename=buf;
filename2=buf2;
sourcefilename=buf3;
sprintf(filename,"pionnormcorrelator_finiteT.%.6d",traj);
sprintf(filename2,"%s", "pion_norm.data");
/* generate random source point */
if(ranlxs_init == 0) {
rlxs_init(1, 123456);
}
ranlxs(&tmp, 1);
z0 = (int)(measurement_list[id].max_source_slice*tmp);
#ifdef MPI
MPI_Bcast(&z0, 1, MPI_INT, 0, MPI_COMM_WORLD);
#endif
#ifdef MPI
atime = MPI_Wtime();
#else
atime = (double)clock()/(double)(CLOCKS_PER_SEC);
#endif
Cpp = (double*) calloc(g_nproc_z*LZ, sizeof(double));
printf("Doing finite Temperature online measurement\n");
/* stochastic source in z-slice */
source_generation_pion_zdir(g_spinor_field[0], g_spinor_field[1],
z0, 0, traj);
/* invert on the stochastic source */
invert_eo(g_spinor_field[2], g_spinor_field[3],
g_spinor_field[0], g_spinor_field[1],
1.e-14, measurement_list[id].max_iter, CG, 1, 0, 1, 0, NULL, -1);
/* now we bring it to normal format */
/* here we use implicitly DUM_MATRIX and DUM_MATRIX+1 */
convert_eo_to_lexic(g_spinor_field[DUM_MATRIX], g_spinor_field[2], g_spinor_field[3]);
/* now we sums only over local space for every z */
for(z = 0; z < LZ; z++) {
res = 0.;
/* sum here over all points in one z-slice
we have to look up g_ipt*/
j = g_ipt[0][0][0][z];
for(i = 0; i < T*LX*LY ; i++) {
res += _spinor_prod_re(g_spinor_field[DUM_MATRIX][j], g_spinor_field[DUM_MATRIX][j]);
j += LZ; /* jump LZ sites in array, z ist fastest index */
}
#if defined MPI
MPI_Reduce(&res, &mpi_res, 1, MPI_DOUBLE, MPI_SUM, 0, g_mpi_z_slices);
res = mpi_res;
#endif
Cpp[z+g_proc_coords[3]*LZ] = +res/(g_nproc_x*LX)/(g_nproc_y*LY)/(g_nproc_t*T)*2.;
}
#ifdef MPI
/* some gymnastics needed in case of parallelisation */
if(g_mpi_z_rank == 0) {
MPI_Gather(&Cpp[g_proc_coords[3]*LZ], LZ, MPI_DOUBLE, Cpp, LZ, MPI_DOUBLE, 0, g_mpi_ST_slices);
}
#endif
/* and write everything into a file */
if(g_mpi_z_rank == 0 && g_proc_coords[3] == 0) {
ofs = fopen(filename, "w");
fprintf( ofs, "1 1 0 %e %e\n", Cpp[z0], 0.);
for(z = 1; z < g_nproc_z*LZ/2; z++) {
zz = (z0+z)%(g_nproc_z*LZ);
fprintf( ofs, "1 1 %d %e ", z, Cpp[zz]);
zz = (z0+g_nproc_z*LZ-z)%(g_nproc_z*LZ);
fprintf( ofs, "%e\n", Cpp[zz]);
}
zz = (z0+g_nproc_z*LZ/2)%(g_nproc_z*LZ);
fprintf( ofs, "1 1 %d %e %e\n", z, Cpp[zz], 0.);
fclose(ofs);
/* sum over all Cpp to get pionnorm*/
ofs2 = fopen(filename2, "a");
pionnorm = 0.;
for(z=0; z<g_nproc_z*LZ; z++){
pionnorm += Cpp[z];
}
/* normalize */
pionnorm = pionnorm/(g_nproc_z*LZ);
fprintf(ofs2,"%d\t %.16e\n",traj,pionnorm);
fclose(ofs2);
}
free(Cpp);
#ifdef MPI
etime = MPI_Wtime();
#else
etime = (double)clock()/(double)(CLOCKS_PER_SEC);
#endif
if(g_proc_id == 0 && g_debug_level > 0) {
printf("PIONNORM : measurement done int t/s = %1.4e\n", etime - atime);
}
return;
}
int main(int argc,char *argv[]) {
FILE *parameterfile=NULL;
int c, j, is=0, ic=0;
int x, X, y, Y, z, Z, t, tt, i, sum;
char * filename = NULL;
char datafilename[50];
char parameterfilename[50];
char conf_filename[50];
char * input_filename = NULL;
double plaquette_energy, nrm;
double * norm;
struct stout_parameters params_smear;
#ifdef _GAUGE_COPY
int kb=0;
#endif
#ifdef MPI
double atime=0., etime=0.;
#endif
#ifdef _KOJAK_INST
#pragma pomp inst init
#pragma pomp inst begin(main)
#endif
DUM_DERI = 6;
/* DUM_DERI + 2 is enough (not 7) */
DUM_SOLVER = DUM_DERI+2;
DUM_MATRIX = DUM_SOLVER+6;
/* DUM_MATRIX + 2 is enough (not 6) */
NO_OF_SPINORFIELDS = DUM_MATRIX+2;
verbose = 0;
g_use_clover_flag = 0;
g_nr_of_psf = 1;
#ifdef MPI
MPI_Init(&argc, &argv);
#endif
while ((c = getopt(argc, argv, "h?f:o:")) != -1) {
switch (c) {
case 'f':
input_filename = calloc(200, sizeof(char));
strcpy(input_filename,optarg);
break;
case 'o':
filename = calloc(200, sizeof(char));
strcpy(filename,optarg);
break;
case 'h':
case '?':
default:
usage();
break;
}
}
if(input_filename == NULL){
input_filename = "hmc.input";
}
if(filename == NULL){
filename = "output";
}
/* Read the input file */
read_input(input_filename);
/* here we want no even/odd preconditioning */
even_odd_flag = 0;
/* this DBW2 stuff is not needed for the inversion ! */
g_rgi_C1 = 0;
if(Nsave == 0){
Nsave = 1;
}
tmlqcd_mpi_init(argc, argv);
g_dbw2rand = 0;
#ifndef MPI
g_dbw2rand = 0;
#endif
#ifdef _GAUGE_COPY
j = init_gauge_field(VOLUMEPLUSRAND, 1);
#else
j = init_gauge_field(VOLUMEPLUSRAND, 0);
#endif
if ( j!= 0) {
fprintf(stderr, "Not enough memory for gauge_fields! Aborting...\n");
exit(-1);
}
j = init_geometry_indices(VOLUMEPLUSRAND);
if ( j!= 0) {
fprintf(stderr, "Not enough memory for geometry indices! Aborting...\n");
exit(-1);
}
if(even_odd_flag) {
j = init_spinor_field(VOLUMEPLUSRAND/2, NO_OF_SPINORFIELDS);
}
else {
j = init_spinor_field(VOLUMEPLUSRAND, NO_OF_SPINORFIELDS);
}
if ( j!= 0) {
fprintf(stderr, "Not enough memory for spinor fields! Aborting...\n");
exit(-1);
}
g_mu = g_mu1;
if(g_proc_id == 0){
/*construct the filenames for the observables and the parameters*/
strcpy(datafilename,filename); strcat(datafilename,".data");
strcpy(parameterfilename,filename); strcat(parameterfilename,".para");
parameterfile=fopen(parameterfilename, "w");
write_first_messages(parameterfile, 0, 1);
}
/* define the geometry */
geometry();
/* define the boundary conditions for the fermion fields */
boundary();
#ifdef _USE_HALFSPINOR
j = init_dirac_halfspinor();
if ( j!= 0) {
fprintf(stderr, "Not enough memory for halffield! Aborting...\n");
exit(-1);
}
if(g_sloppy_precision_flag == 1) {
j = init_dirac_halfspinor32();
if ( j!= 0) {
fprintf(stderr, "Not enough memory for 32-Bit halffield! Aborting...\n");
exit(-1);
}
}
# if (defined _PERSISTENT)
init_xchange_halffield();
# endif
#endif
norm = (double*)calloc(3.*LX/2.+T/2., sizeof(double));
for(j=0;j<Nmeas; j++) {
sprintf(conf_filename,"%s.%.4d", gauge_input_filename, nstore);
if (g_proc_id == 0){
printf("Reading Gauge field from file %s\n", conf_filename); fflush(stdout);
}
read_lime_gauge_field(conf_filename);
if (g_proc_id == 0){
printf("done!\n"); fflush(stdout);
}
#ifdef MPI
xchange_gauge();
#endif
#ifdef _GAUGE_COPY
update_backward_gauge();
#endif
/* Compute minimal eigenvalues, if wanted */
if(compute_evs != 0) {
eigenvalues(&no_eigenvalues, 1000, eigenvalue_precision, 0, compute_evs, nstore, even_odd_flag);
}
/*compute the energy of the gauge field*/
plaquette_energy = measure_gauge_action();
if(g_proc_id == 0) {
printf("The plaquette value is %e\n", plaquette_energy/(6.*VOLUME*g_nproc)); fflush(stdout);
}
if (use_stout_flag == 1){
params_smear.rho = stout_rho;
params_smear.iterations = stout_no_iter;
if (stout_smear((su3_tuple*)(g_gauge_field[0]), ¶ms_smear, (su3_tuple*)(g_gauge_field[0])) != 0)
exit(1) ;
g_update_gauge_copy = 1;
g_update_gauge_energy = 1;
g_update_rectangle_energy = 1;
plaquette_energy = measure_gauge_action();
if (g_proc_id == 0) {
printf("# The plaquette value after stouting is %e\n", plaquette_energy / (6.*VOLUME*g_nproc));
fflush(stdout);
}
}
source_spinor_field(g_spinor_field[0], g_spinor_field[1], 0, 0);
convert_eo_to_lexic(g_spinor_field[DUM_DERI], g_spinor_field[0], g_spinor_field[1]);
D_psi(g_spinor_field[DUM_DERI+1], g_spinor_field[DUM_DERI]);
if(even_odd_flag) {
i = invert_eo(g_spinor_field[2], g_spinor_field[3], g_spinor_field[0], g_spinor_field[1],
solver_precision, max_solver_iterations, solver_flag, g_relative_precision_flag,
sub_evs_cg_flag, even_odd_flag);
convert_eo_to_lexic(g_spinor_field[DUM_DERI+1], g_spinor_field[2], g_spinor_field[3]);
}
for(i = 0; i < 3*LX/2+T/2; i++){
norm[i] = 0.;
}
for(x = 0; x < LX; x++){
if(x > LX/2) X = LX-x;
else X = x;
for(y = 0; y < LY; y++){
if(y > LY/2) Y = LY-y;
else Y = y;
for(z = 0; z < LZ; z++){
if(z > LZ/2) Z = LZ-z;
else Z = z;
for(t = 0; t < T; t++){
if(t > T/2) tt = T - t;
else tt = t;
sum = X + Y + Z + tt;
_spinor_norm_sq(nrm, g_spinor_field[DUM_DERI+1][ g_ipt[t][x][y][z] ]);
/* _spinor_norm_sq(nrm, qprop[0][0][1][ g_ipt[t][x][y][z] ]); */
printf("%e %e\n", g_spinor_field[DUM_DERI+1][ g_ipt[t][x][y][z] ].s0.c0.re, g_spinor_field[DUM_DERI+1][ g_ipt[t][x][y][z] ].s0.c0.im);
nrm = sqrt( nrm );
printf("%1.12e\n", nrm);
if(nrm > norm[sum]) norm[sum] = nrm;
}
}
}
}
for(i = 0; i < 3*L/2+T/2; i++){
printf("%d %1.12e\n", i, norm[i]);
}
printf("\n");
nstore+=Nsave;
}
#ifdef MPI
MPI_Finalize();
#endif
free_gauge_field();
free_geometry_indices();
free_spinor_field();
free_moment_field();
return(0);
#ifdef _KOJAK_INST
#pragma pomp inst end(main)
#endif
}
void online_measurement(const int traj, const int id) {
int i, j, t, tt, t0;
double *Cpp, *Cpa, *Cp4;
double res = 0., respa = 0., resp4 = 0.;
double atime, etime;
float tmp;
#ifdef MPI
double mpi_res = 0., mpi_respa = 0., mpi_resp4 = 0.;
#endif
FILE *ofs;
char *filename;
char buf[100];
spinor phi;
filename=buf;
sprintf(filename,"%s%.6d", "onlinemeas." ,traj);
/* generate random timeslice */
if(ranlxs_init == 0) {
rlxs_init(1, 123456);
}
ranlxs(&tmp, 1);
t0 = (int)(measurement_list[id].max_source_slice*tmp);
#ifdef MPI
MPI_Bcast(&t0, 1, MPI_INT, 0, MPI_COMM_WORLD);
#endif
if(g_debug_level > 1 && g_proc_id == 0) {
printf("# timeslice set to %d (T=%d) for online measurement\n", t0, g_nproc_t*T);
printf("# online measurements parameters: kappa = %g, mu = %g\n", g_kappa, g_mu/2./g_kappa);
}
#ifdef MPI
atime = MPI_Wtime();
#else
atime = (double)clock()/(double)(CLOCKS_PER_SEC);
#endif
Cpp = (double*) calloc(g_nproc_t*T, sizeof(double));
Cpa = (double*) calloc(g_nproc_t*T, sizeof(double));
Cp4 = (double*) calloc(g_nproc_t*T, sizeof(double));
source_generation_pion_only(g_spinor_field[0], g_spinor_field[1],
t0, 0, traj);
invert_eo(g_spinor_field[2], g_spinor_field[3],
g_spinor_field[0], g_spinor_field[1],
1.e-14, measurement_list[id].max_iter, CG, 1, 0, 1, 0, NULL, -1);
/* now we bring it to normal format */
/* here we use implicitly DUM_MATRIX and DUM_MATRIX+1 */
convert_eo_to_lexic(g_spinor_field[DUM_MATRIX], g_spinor_field[2], g_spinor_field[3]);
/* now we sum only over local space for every t */
for(t = 0; t < T; t++) {
j = g_ipt[t][0][0][0];
res = 0.;
respa = 0.;
resp4 = 0.;
for(i = j; i < j+LX*LY*LZ; i++) {
res += _spinor_prod_re(g_spinor_field[DUM_MATRIX][j], g_spinor_field[DUM_MATRIX][j]);
_gamma0(phi, g_spinor_field[DUM_MATRIX][j]);
respa += _spinor_prod_re(g_spinor_field[DUM_MATRIX][j], phi);
_gamma5(phi, phi);
resp4 += _spinor_prod_im(g_spinor_field[DUM_MATRIX][j], phi);
}
#if defined MPI
MPI_Reduce(&res, &mpi_res, 1, MPI_DOUBLE, MPI_SUM, 0, g_mpi_time_slices);
res = mpi_res;
MPI_Reduce(&respa, &mpi_respa, 1, MPI_DOUBLE, MPI_SUM, 0, g_mpi_time_slices);
respa = mpi_respa;
MPI_Reduce(&resp4, &mpi_resp4, 1, MPI_DOUBLE, MPI_SUM, 0, g_mpi_time_slices);
resp4 = mpi_resp4;
#endif
Cpp[t+g_proc_coords[0]*T] = +res/(g_nproc_x*LX)/(g_nproc_y*LY)/(g_nproc_z*LZ)*2.;
Cpa[t+g_proc_coords[0]*T] = -respa/(g_nproc_x*LX)/(g_nproc_y*LY)/(g_nproc_z*LZ)*2.;
Cp4[t+g_proc_coords[0]*T] = +resp4/(g_nproc_x*LX)/(g_nproc_y*LY)/(g_nproc_z*LZ)*2.;
}
#ifdef MPI
/* some gymnastics needed in case of parallelisation */
if(g_mpi_time_rank == 0) {
MPI_Gather(&Cpp[g_proc_coords[0]*T], T, MPI_DOUBLE, Cpp, T, MPI_DOUBLE, 0, g_mpi_SV_slices);
MPI_Gather(&Cpa[g_proc_coords[0]*T], T, MPI_DOUBLE, Cpa, T, MPI_DOUBLE, 0, g_mpi_SV_slices);
MPI_Gather(&Cp4[g_proc_coords[0]*T], T, MPI_DOUBLE, Cp4, T, MPI_DOUBLE, 0, g_mpi_SV_slices);
}
#endif
/* and write everything into a file */
if(g_mpi_time_rank == 0 && g_proc_coords[0] == 0) {
ofs = fopen(filename, "w");
fprintf( ofs, "1 1 0 %e %e\n", Cpp[t0], 0.);
for(t = 1; t < g_nproc_t*T/2; t++) {
tt = (t0+t)%(g_nproc_t*T);
fprintf( ofs, "1 1 %d %e ", t, Cpp[tt]);
tt = (t0+g_nproc_t*T-t)%(g_nproc_t*T);
fprintf( ofs, "%e\n", Cpp[tt]);
}
tt = (t0+g_nproc_t*T/2)%(g_nproc_t*T);
fprintf( ofs, "1 1 %d %e %e\n", t, Cpp[tt], 0.);
fprintf( ofs, "2 1 0 %e %e\n", Cpa[t0], 0.);
for(t = 1; t < g_nproc_t*T/2; t++) {
tt = (t0+t)%(g_nproc_t*T);
fprintf( ofs, "2 1 %d %e ", t, Cpa[tt]);
tt = (t0+g_nproc_t*T-t)%(g_nproc_t*T);
fprintf( ofs, "%e\n", Cpa[tt]);
}
tt = (t0+g_nproc_t*T/2)%(g_nproc_t*T);
fprintf( ofs, "2 1 %d %e %e\n", t, Cpa[tt], 0.);
fprintf( ofs, "6 1 0 %e %e\n", Cp4[t0], 0.);
for(t = 1; t < g_nproc_t*T/2; t++) {
tt = (t0+t)%(g_nproc_t*T);
fprintf( ofs, "6 1 %d %e ", t, Cp4[tt]);
tt = (t0+g_nproc_t*T-t)%(g_nproc_t*T);
fprintf( ofs, "%e\n", Cp4[tt]);
}
tt = (t0+g_nproc_t*T/2)%(g_nproc_t*T);
fprintf( ofs, "6 1 %d %e %e\n", t, Cp4[tt], 0.);
fclose(ofs);
}
free(Cpp); free(Cpa); free(Cp4);
#ifdef MPI
etime = MPI_Wtime();
#else
etime = (double)clock()/(double)(CLOCKS_PER_SEC);
#endif
if(g_proc_id == 0 && g_debug_level > 0) {
printf("ONLINE: measurement done int t/s = %1.4e\n", etime - atime);
}
return;
}