void tm_times_Hopping_Matrix(const int ieo, spinor * const l, spinor * const k, double complex const cfactor) { # ifdef XLC # pragma disjoint(*l, *k) # endif # ifdef _GAUGE_COPY if(g_update_gauge_copy) { update_backward_gauge(g_gauge_field); } # endif # if (defined MPI) xchange_field(k, ieo); # endif # ifdef OMP # pragma omp parallel { # endif # define _MUL_G5_CMPLX # if (defined BGQ && defined XLC) complex double ALIGN bla = cfactor; vector4double ALIGN cf = vec_ld2(0, (double*) &bla); # elif (defined SSE2 || defined SSE3) _Complex double ALIGN cf = cfactor; # endif # include "operator/hopping_body_dbl.c" # undef _MUL_G5_CMPLX # ifdef OMP } /* OpenMP closing brace */ # endif return; }
void Hopping_Matrix(const int ieo, spinor * const l, spinor * const k) { # ifdef XLC # pragma disjoint(*l, *k) # endif # ifdef _GAUGE_COPY if(g_update_gauge_copy) { update_backward_gauge(g_gauge_field); } # endif # if (defined TM_USE_MPI && !(defined _NO_COMM)) xchange_field(k, ieo); # endif # ifdef TM_USE_OMP # pragma omp parallel { # endif # include "operator/hopping_body_dbl.c" # ifdef TM_USE_OMP } /* OpenMP closing brace */ # endif return; }
void tm_sub_Hopping_Matrix(const int ieo, spinor * const l, spinor * p, spinor * const k, complex double const cfactor) { # ifdef XLC # pragma disjoint(*l, *k) # endif # ifdef _GAUGE_COPY if(g_update_gauge_copy) { update_backward_gauge(g_gauge_field); } # endif # if (defined TM_USE_MPI) xchange_field(k, ieo); # endif # ifdef TM_USE_OMP # pragma omp parallel { # endif # define _TM_SUB_HOP spinor * pn; # if (defined BGQ && defined XLC) complex double ALIGN bla = cfactor; vector4double ALIGN cf = vec_ld2(0, (double*) &bla); # elif (defined SSE2 || defined SSE3) _Complex double ALIGN cf = cfactor; su3_vector ALIGN psi, psi2; # endif # include "operator/hopping_body_dbl.c" # undef _TM_SUB_HOP # ifdef TM_USE_OMP } /* OpenMP closing brace */ # endif return; }
void deriv_Sb_D_psi(spinor * const l, spinor * const k, hamiltonian_field_t * const hf, const double factor) { int ix,iy, iz; int ioff,ioff2,icx,icy, icz; su3 * restrict up ALIGN; su3 * restrict um ALIGN; su3adj * restrict ddd; static su3adj der; static su3 v1,v2; static su3_vector psia,psib,phia,phib; static spinor rr; spinor * restrict r ALIGN; spinor * restrict sp ALIGN; spinor * restrict sm ALIGN; /* We have 32 registers available */ double _Complex reg00, reg01, reg02, reg03, reg04, reg05; double _Complex reg10, reg11, reg12, reg13, reg14, reg15; /* For su3 matrix, use reg00 for missing register */ double _Complex v00, v01, v02, v10, v11, v12, v20, v21; /* The following contains the left spinor (12 regs) and the final */ /* su3 matrix to trace over */ double _Complex r00, r01, r02, r10, r11, r12, r20, r21, r22, r30, r31, r32; #ifdef _KOJAK_INST # pragma pomp inst begin(derivSb) #endif #pragma disjoint(*r, *sp, *sm, *up, *um, *ddd) __alignx(16, l); __alignx(16, k); if(ieo==0) { ioff=0; } else { ioff=(VOLUME+RAND)/2; } ioff2=(VOLUME+RAND)/2-ioff; /* for parallelization */ #ifdef MPI xchange_field(k, ieo); xchange_field(l, (ieo+1)%2); #endif /************** loop over all lattice sites ****************/ ix=ioff; iy=g_iup[ix][0]; icy=iy; sp = k + icy; _prefetch_spinor(sp); up=&hf->gaugefield[ix][0]; _prefetch_su3(up); for(icx = ioff; icx < (VOLUME+ioff); icx++){ /* load left vector r and */ /* multiply with gamma5 */ r = l + (icx-ioff); ix=icx; /*********************** direction +0 ********************/ ddd = &hf->derivative[ix][0]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_add_to_reg0_reg1(); _bgl_add_to_reg0_up_reg1_up(); _bgl_add_r0_to_r2_reg1(); _bgl_add_r1_to_r3_reg1_up(); iy=g_idn[ix][0]; icy=iy; sm = k + icy; _prefetch_spinor(sm); um=&hf->gaugefield[iy][0]; _prefetch_su3(um); _bgl_tensor_product_and_add(); /* result in v now */ _bgl_su3_times_v_dagger(*up); /* result in r now */ _bgl_complex_times_r(ka0); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /************** direction -0 ****************************/ ddd = &hf->derivative[iy][0]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sm).s0); _bgl_load_reg0_up((*sm).s1); _bgl_load_reg1((*sm).s2); _bgl_load_reg1_up((*sm).s3); _bgl_sub_from_reg0_reg1(); _bgl_sub_from_reg0_up_reg1_up(); _bgl_sub_from_r0_r2_reg1(); _bgl_sub_from_r1_r3_reg1_up(); iy=g_iup[ix][1]; icy=[iy]; sp = k + icy; _prefetch_spinor(sp); up=&hf->gaugefield[ix][1]; _prefetch_su3(up); _bgl_tensor_product_and_add_d(); /* result in v now */ _bgl_su3_times_v_dagger(*um); /* result in r now */ _bgl_complex_times_r(ka0); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /*************** direction +1 **************************/ ddd = &hf->derivative[ix][1]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_i_mul_add_to_reg0_reg1_up(); _bgl_i_mul_add_to_reg0_up_reg1(); _bgl_i_mul_add_r0_to_r3_reg1(); _bgl_i_mul_add_r1_to_r2_reg1_up(); iy=g_idn[ix][1]; icy=iy; sm = k + icy; _prefetch_spinor(sm); um=&hf->gaugefield[iy][1]; _prefetch_su3(um); _bgl_tensor_product_and_add(); /* result in v now */ _bgl_su3_times_v_dagger(*up); /* result in r now */ _bgl_complex_times_r(ka1); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /**************** direction -1 *************************/ ddd = &hf->derivative[iy][1]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_i_mul_sub_from_reg0_reg1_up(); _bgl_i_mul_sub_from_reg0_up_reg1(); _bgl_i_mul_sub_from_r0_r3_reg1(); _bgl_i_mul_sub_from_r1_r2_reg1_up(); iy=g_iup[ix][2]; icy=iy; sp = k + icy; _prefetch_spinor(sp); up=&hf->gaugefield[ix][2]; _prefetch_su3(up); _bgl_tensor_product_and_add_d(); /* result in v now */ _bgl_su3_times_v_dagger(*um); /* result in r now */ _bgl_complex_times_r(ka1); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /*************** direction +2 **************************/ ddd = &hf->derivative[ix][2]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_add_to_reg0_reg1_up(); _bgl_sub_from_reg0_up_reg1(); _bgl_add_r0_to_r3_reg1(); _bgl_sub_from_r1_r2_reg1_up(); iy=g_idn[ix][2]; icy=iy; sm = k + icy; _prefetch_spinor(sm); um=&hf->gaugefield[iy][2]; _prefetch_su3(um); _bgl_tensor_product_and_add(); /* result in v now */ _bgl_su3_times_v_dagger(*up); /* result in r now */ _bgl_complex_times_r(ka2); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /***************** direction -2 ************************/ ddd = &hf->derivative[iy][2]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_sub_from_reg0_reg1_up(); _bgl_add_to_reg0_up_reg1(); _bgl_sub_from_r0_r3_reg1(); _bgl_add_r1_to_r2_reg1_up(); iy=g_iup[ix][3]; icy=iy; sp = k + icy; _prefetch_spinor(sp); up=&hf->gaugefield[ix][3]; _prefetch_su3(up); _bgl_tensor_product_and_add_d(); /* result in v now */ _bgl_su3_times_v_dagger(*um); /* result in r now */ _bgl_complex_times_r(ka1); _bgl_trace_lambda_mul_add_assign(*ddd, 2.*factor); /****************** direction +3 ***********************/ ddd = &hf->derivative[ix][3]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_i_mul_add_to_reg0_reg1(); _bgl_i_mul_sub_from_reg0_up_reg1_up(); _bgl_i_mul_add_r0_to_r2_reg1(); _bgl_i_mul_sub_from_r1_r3_reg1_up(); iy=g_idn[ix][3]; icy=iy; sm = k + icy; _prefetch_spinor(sm); um=&hf->gaugefield[iy][3]; _prefetch_su3(um); _bgl_tensor_product_and_add(); /* result in v now */ _bgl_su3_times_v_dagger(*up); /* result in r now */ _bgl_complex_times_r(ka3); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /***************** direction -3 ************************/ ddd = &hf->derivative[iy][3]; _bgl_load_r0((*r).s0); _bgl_load_r1((*r).s1); _bgl_load_minus_r2((*r).s2); _bgl_load_minus_r3((*r).s3); _bgl_load_reg0((*sp).s0); _bgl_load_reg0_up((*sp).s1); _bgl_load_reg1((*sp).s2); _bgl_load_reg1_up((*sp).s3); _bgl_i_mul_sub_from_reg0_reg1(); _bgl_i_mul_add_to_reg0_up_reg1_up(); _bgl_i_mul_sub_from_r0_r2_reg1(); _bgl_i_mul_add_r1_to_r3_reg1_up(); /* something wrong here...*/ icz=icx+1; if(icz==((VOLUME+RAND)/2+ioff)) icz=ioff; iz=icz; iy=g_iup[iz][0]; icy=iy; sp = k + icy; _prefetch_spinor(sp); up=&hf->gaugefield[iz][0]; _prefetch_su3(up); _bgl_tensor_product_and_add_d(); /* result in v now */ _bgl_su3_times_v_dagger(*um); /* result in r now */ _bgl_complex_times_r(ka3); _bgl_trace_lambda_mul_add_assign((*ddd), 2.*factor); /****************** end of loop ************************/ } #ifdef _KOJAK_INST #pragma pomp inst end(derivSb) #endif }
int main(int argc, char **argv) { int c, i, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix, iix; int dxm[4], dxn[4], ixpm, ixpn; int sid; double *disc = (double*)NULL; double *disc2 = (double*)NULL; double *work = (double*)NULL; double q[4], fnorm; int verbose = 0; int do_gt = 0; char filename[100], contype[200]; double ratime, retime; double plaq, _2kappamu, hpe3_coeff, onepmutilde2, mutilde2; double spinor1[24], spinor2[24], U_[18], U1_[18], U2_[18]; double *gauge_trafo=(double*)NULL; complex w, w1, w2, *cp1, *cp2, *cp3; FILE *ofs; fftw_complex *in=(fftw_complex*)NULL; #ifdef MPI fftwnd_mpi_plan plan_p, plan_m; #else fftwnd_plan plan_p, plan_m; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vgf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'g': do_gt = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# Reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); /* initialize fftw */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; #ifdef MPI plan_p = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_BACKWARD, FFTW_MEASURE); plan_m = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_FORWARD, FFTW_MEASURE); fftwnd_mpi_local_sizes(plan_p, &T, &Tstart, &l_LX_at, &l_LXstart_at, &FFTW_LOC_VOLUME); #else plan_p = fftwnd_create_plan(4, dims, FFTW_BACKWARD, FFTW_MEASURE | FFTW_IN_PLACE); plan_m = fftwnd_create_plan(4, dims, FFTW_FORWARD, FFTW_MEASURE | FFTW_IN_PLACE); T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; #endif fprintf(stdout, "# [%2d] fftw parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); #ifdef MPI if(T==0) { fprintf(stderr, "[%2d] local T is zero; exit\n", g_cart_id); MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(2); } #endif if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); /* read the gauge field */ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); #ifdef MPI xchange_gauge(); #endif /* measure the plaquette */ plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value: %25.16e\n", plaq); if(do_gt==1) { /*********************************** * initialize gauge transformation ***********************************/ init_gauge_trafo(&gauge_trafo, 1.); apply_gt_gauge(gauge_trafo); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value after gauge trafo: %25.16e\n", plaq); } /**************************************** * allocate memory for the spinor fields ****************************************/ no_fields = 3; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /**************************************** * allocate memory for the contractions ****************************************/ disc = (double*)calloc( 8*VOLUME, sizeof(double)); if( disc == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(3); } for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; disc2 = (double*)calloc( 8*VOLUME, sizeof(double)); if( disc2 == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc2\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(3); } for(ix=0; ix<8*VOLUME; ix++) disc2[ix] = 0.; work = (double*)calloc(48*VOLUME, sizeof(double)); if( work == (double*)NULL ) { fprintf(stderr, "could not allocate memory for work\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(3); } /**************************************** * prepare Fourier transformation arrays ****************************************/ in = (fftw_complex*)malloc(FFTW_LOC_VOLUME*sizeof(fftw_complex)); if(in==(fftw_complex*)NULL) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(4); } /************************************************ * HPE: calculate coeff. of 3rd order term ************************************************/ _2kappamu = 2. * g_kappa * g_mu; onepmutilde2 = 1. + _2kappamu * _2kappamu; mutilde2 = _2kappamu * _2kappamu; hpe3_coeff = 16. * g_kappa*g_kappa*g_kappa*g_kappa * (1. + 6. * mutilde2 + mutilde2*mutilde2) / onepmutilde2 / onepmutilde2 / onepmutilde2 / onepmutilde2; /* hpe3_coeff = 8. * g_kappa*g_kappa*g_kappa * \ (1. + 6.*_2kappamu*_2kappamu + _2kappamu*_2kappamu*_2kappamu*_2kappamu) / (1. + _2kappamu*_2kappamu) / (1. + _2kappamu*_2kappamu) / (1. + _2kappamu*_2kappamu) / (1. + _2kappamu*_2kappamu); */ fprintf(stdout, "hpe3_coeff = %25.16e\n", hpe3_coeff); /************************************************ * HPE: calculate the plaquette terms ************************************************/ for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<4; mu++) { for(i=1; i<4; i++) { nu = (mu+i)%4; _cm_eq_cm_ti_cm(U1_, g_gauge_field+_GGI(ix,mu), g_gauge_field+_GGI(g_iup[ix][mu],nu) ); _cm_eq_cm_ti_cm(U2_, g_gauge_field+_GGI(ix,nu), g_gauge_field+_GGI(g_iup[ix][nu],mu) ); _cm_eq_cm_ti_cm_dag(U_, U1_, U2_); _co_eq_tr_cm(&w1, U_); iix = g_idn[ix][nu]; _cm_eq_cm_ti_cm(U1_, g_gauge_field+_GGI(iix,mu), g_gauge_field+_GGI(g_iup[iix][mu],nu) ); _cm_eq_cm_ti_cm(U2_, g_gauge_field+_GGI(iix,nu), g_gauge_field+_GGI(g_iup[iix][nu],mu) ); _cm_eq_cm_ti_cm_dag(U_, U1_, U2_); _co_eq_tr_cm(&w2, U_); disc2[_GWI(mu,ix,VOLUME)+1] += hpe3_coeff * (w1.im - w2.im); /* _cm_eq_cm_ti_cm(U1_, g_gauge_field+_GGI(g_idn[ix][nu],nu), g_gauge_field+_GGI(ix,mu) ); _cm_eq_cm_ti_cm(U2_, g_gauge_field+_GGI(g_idn[ix][nu],mu), g_gauge_field+_GGI(g_iup[g_idn[ix][nu]][mu], nu) ); _cm_eq_cm_ti_cm_dag(U_, U1_, U2_); _co_eq_tr_cm(&w2, U_); disc2[_GWI(mu,ix,VOLUME)+1] += hpe3_coeff * (w1.im + w2.im); */ /* fprintf(stdout, "mu=%1d, ix=%5d, nu=%1d, w1=%25.16e +i %25.16e; w2=%25.16e +i %25.16e\n", mu, ix, nu, w1.re, w1.im, w2.re, w2.im); */ } /* of nu */ /**************************************** * - in case lattice size equals 4 * calculate additional loop term * - _NOTE_ the possible minus sign from * the fermionic boundary conditions ****************************************/ if(dims[mu]==4) { wilson_loop(&w, ix, mu, dims[mu]); fnorm = -64. * g_kappa*g_kappa*g_kappa*g_kappa / onepmutilde2 / onepmutilde2 / onepmutilde2 / onepmutilde2; disc2[_GWI(mu,ix,VOLUME)+1] += fnorm * w.im; /* fprintf(stdout, "loop contribution: ix=%5d, mu=%2d, fnorm=%25.16e, w=%25.16e\n", ix, mu, fnorm, w.im); */ } /* fprintf(stdout, "-------------------------------------------\n"); fprintf(stdout, "disc2[ix=%d,mu=%d] = %25.16e +i %25.16e\n", ix, mu, disc2[_GWI(mu,ix,VOLUME)], disc2[_GWI(mu,ix,VOLUME)+1]); fprintf(stdout, "-------------------------------------------\n"); */ } } /* sprintf(filename, "avc_disc_hpe5_3rd.%.4d", Nconf); ofs = fopen(filename, "w"); for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<4; mu++) { fprintf(ofs, "%6d%3d%25.16e\t%25.16e\n", ix, mu, disc[_GWI(mu,ix,VOLUME)], disc[_GWI(mu,ix,VOLUME)+1]); } } fclose(ofs); for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; */ /* for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { ix = g_ipt[x0][x1][x2][x3]; for(mu=0; mu<4; mu++) { dxm[0]=0; dxm[1]=0; dxm[2]=0; dxm[3]=0; dxm[mu]=1; for(i=1; i<4; i++) { nu = (mu+i)%4; dxn[0]=0; dxn[1]=0; dxn[2]=0; dxn[3]=0; dxn[nu]=1; ixpm = g_ipt[(x0+dxm[0]+T)%T][(x1+dxm[1]+LX)%LX][(x2+dxm[2]+LY)%LY][(x3+dxm[3]+LZ)%LZ]; ixpn = g_ipt[(x0+dxn[0]+T)%T][(x1+dxn[1]+LX)%LX][(x2+dxn[2]+LY)%LY][(x3+dxn[3]+LZ)%LZ]; _cm_eq_cm_ti_cm(U1_, g_gauge_field + 72*ix+18*mu, g_gauge_field + 72*ixpm+18*nu ); _cm_eq_cm_ti_cm(U2_, g_gauge_field + 72*ix+18*nu, g_gauge_field + 72*ixpn+18*mu ); _cm_eq_cm_ti_cm_dag(U_, U1_, U2_); _co_eq_tr_cm(&w1, U_); ixpm = g_ipt[(x0+dxm[0]-dxn[0]+T)%T][(x1+dxm[1]-dxn[1]+LX)%LX][(x2+dxm[2]-dxn[2]+LY)%LY][(x3+dxm[3]-dxn[3]+LZ)%LZ]; ixpn = g_ipt[(x0-dxn[0]+T)%T][(x1-dxn[1]+LX)%LX][(x2-dxn[2]+LY)%LY][(x3-dxn[3]+LZ)%LZ]; _cm_eq_cm_ti_cm(U1_, g_gauge_field + 72*ixpn+18*nu, g_gauge_field + 72*ix+18*mu); _cm_eq_cm_ti_cm(U2_, g_gauge_field + 72*ixpn+18*mu, g_gauge_field + 72*ixpm+18*nu); _cm_eq_cm_ti_cm_dag(U_, U1_, U2_); _co_eq_tr_cm(&w2, U_); disc2[_GWI(mu,ix,VOLUME)+1] += hpe3_coeff * (w1.im + w2.im); fprintf(stdout, "mu=%1d, ix=%5d, nu=%1d, w1=%25.16e; w2=%25.16e\n", mu, ix, nu, w1.im, w2.im); } fprintf(stdout, "-------------------------------------------\n"); fprintf(stdout, "disc2[ix=%d,mu=%d] = %25.16e +i %25.16e\n", ix, mu, disc2[_GWI(mu,ix,VOLUME)], disc2[_GWI(mu,ix,VOLUME)+1]); fprintf(stdout, "-------------------------------------------\n"); } } } } } */ /*********************************************** * start loop on source id.s ***********************************************/ for(sid=g_sourceid; sid<=g_sourceid2; sid+=g_sourceid_step) { /* read the new propagator */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid); if(read_lime_spinor(g_spinor_field[2], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, Nconf, sid); if(read_cmi(g_spinor_field[2], filename) != 0) break; } xchange_field(g_spinor_field[2]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "time to read prop.: %e seconds\n", retime-ratime); if(do_gt==1) { /****************************************** * gauge transform the propagators for sid ******************************************/ for(ix=0; ix<VOLUME; ix++) { _fv_eq_cm_ti_fv(spinor1, gauge_trafo+18*ix, g_spinor_field[2]+_GSI(ix)); _fv_eq_fv(g_spinor_field[2]+_GSI(ix), spinor1); } xchange_field(g_spinor_field[2]); } count++; /************************************************ * calculate the source: apply Q_phi_tbc ************************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_phi_tbc(g_spinor_field[0], g_spinor_field[2]); xchange_field(g_spinor_field[0]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "time to calculate source: %e seconds\n", retime-ratime); /************************************************ * HPE: apply BH5 ************************************************/ BH5(g_spinor_field[1], g_spinor_field[2]); /* add new contractions to (existing) disc */ # ifdef MPI ratime = MPI_Wtime(); # else ratime = (double)clock() / CLOCKS_PER_SEC; # endif for(mu=0; mu<4; mu++) { /* loop on Lorentz index of the current */ iix = _GWI(mu,0,VOLUME); for(ix=0; ix<VOLUME; ix++) { /* loop on lattice sites */ _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix, mu)], &co_phase_up[mu]); /* first contribution */ _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(ix)], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; /* second contribution */ _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(g_iup[ix][mu])], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; iix += 2; } /* of ix */ } /* of mu */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to contract cvc: %e seconds\n", retime-ratime); /************************************************ * save results for count = multiple of Nsave ************************************************/ if(count%Nsave == 0) { if(g_cart_id == 0) fprintf(stdout, "save results for count = %d\n", count); fnorm = 1. / ( (double)count * g_prop_normsqr ); if(g_cart_id==0) fprintf(stdout, "# X-fnorm = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(ix=0; ix<VOLUME; ix++) { work[_GWI(mu,ix,VOLUME) ] = disc[_GWI(mu,ix,VOLUME) ] * fnorm + disc2[_GWI(mu,ix,VOLUME) ]; work[_GWI(mu,ix,VOLUME)+1] = disc[_GWI(mu,ix,VOLUME)+1] * fnorm + disc2[_GWI(mu,ix,VOLUME)+1]; } } /* save the result in position space */ sprintf(filename, "cvc_hpe5_X.%.4d.%.4d", Nconf, count); sprintf(contype, "cvc-disc-all-hpe-05-X"); write_lime_contraction(work, filename, 64, 4, contype, Nconf, count); /* sprintf(filename, "cvc_hpe5_Xascii.%.4d.%.4d", Nconf, count); write_contraction(work, NULL, filename, 4, 2, 0); */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /* Fourier transform data, copy to work */ for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(work+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif memcpy((void*)(work+_GWI(4+mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); memcpy((void*)in, (void*)(work+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif memcpy((void*)(work+_GWI(mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } /* of mu =0 ,..., 3*/ fnorm = 1. / (double)(T_global*LX*LY*LZ); if(g_cart_id==0) fprintf(stdout, "# P-fnorm = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(work+_GWI(mu,0,VOLUME)); cp2 = (complex*)(work+_GWI(4+nu,0,VOLUME)); cp3 = (complex*)(work+_GWI(8+4*mu+nu,0,VOLUME)); for(x0=0; x0<T; x0++) { q[0] = (double)(x0+Tstart) / (double)T_global; for(x1=0; x1<LX; x1++) { q[1] = (double)(x1) / (double)LX; for(x2=0; x2<LY; x2++) { q[2] = (double)(x2) / (double)LY; for(x3=0; x3<LZ; x3++) { q[3] = (double)(x3) / (double)LZ; ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * (q[mu]-q[nu]) ); w.im = sin( M_PI * (q[mu]-q[nu]) ); _co_eq_co_ti_co(&w1, cp1, cp2); _co_eq_co_ti_co(cp3, &w1, &w); _co_ti_eq_re(cp3, fnorm); cp1++; cp2++; cp3++; } } } } } } /* save the result in momentum space */ sprintf(filename, "cvc_hpe5_P.%.4d.%.4d", Nconf, count); sprintf(contype, "cvc-disc-all-hpe-05-P"); write_lime_contraction(work+_GWI(8,0,VOLUME), filename, 64, 16, contype, Nconf, count); /* sprintf(filename, "cvc_hpe5_Pascii.%.4d.%.4d", Nconf, count); write_contraction(work+_GWI(8,0,VOLUME), NULL, filename, 16, 2, 0); */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to save cvc results: %e seconds\n", retime-ratime); } /* of count % Nsave == 0 */ } /* of loop on sid */ /*********************************************** * free the allocated memory, finalize ***********************************************/ free(g_gauge_field); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); fftw_free(in); free(disc); free(work); #ifdef MPI fftwnd_mpi_destroy_plan(plan_p); fftwnd_mpi_destroy_plan(plan_m); MPI_Finalize(); #else fftwnd_destroy_plan(plan_p); fftwnd_destroy_plan(plan_m); #endif return(0); }
int main(int argc, char **argv) { int c, i, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix, iix; int dxm[4], dxn[4], ixpm, ixpn; int sid; double *disc = (double*)NULL; double *work = (double*)NULL; double q[4], fnorm; int verbose = 0; int do_gt = 0; char filename[100]; double ratime, retime; double plaq, _2kappamu, hpe3_coeff, onepmutilde2, mutilde2; double spinor1[24], spinor2[24], U_[18], U1_[18], U2_[18]; double *gauge_trafo=(double*)NULL; complex w, w1, w2, *cp1, *cp2, *cp3; FILE *ofs; fftw_complex *in=(fftw_complex*)NULL; #ifdef MPI fftwnd_mpi_plan plan_p, plan_m; int *status; #else fftwnd_plan plan_p, plan_m; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vgf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'g': do_gt = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ set_default_input_values(); if(filename_set==0) strcpy(filename, "cvc.input"); /* read the input file */ read_input(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); #ifdef MPI if((status = (int*)calloc(g_nproc, sizeof(int))) == (int*)NULL) { MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(7); } #endif /* initialize fftw */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; #ifdef MPI plan_p = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_BACKWARD, FFTW_MEASURE); plan_m = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_FORWARD, FFTW_MEASURE); fftwnd_mpi_local_sizes(plan_p, &T, &Tstart, &l_LX_at, &l_LXstart_at, &FFTW_LOC_VOLUME); #else plan_p = fftwnd_create_plan(4, dims, FFTW_BACKWARD, FFTW_MEASURE | FFTW_IN_PLACE); plan_m = fftwnd_create_plan(4, dims, FFTW_FORWARD, FFTW_MEASURE | FFTW_IN_PLACE); T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; #endif fprintf(stdout, "# [%2d] fftw parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); #ifdef MPI if(T==0) { fprintf(stderr, "[%2d] local T is zero; exit\n", g_cart_id); MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(2); } #endif if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); /* read the gauge field */ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); /* measure the plaquette */ plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value: %25.16e\n", plaq); if(do_gt==1) { /*********************************** * initialize gauge transformation ***********************************/ init_gauge_trafo(&gauge_trafo, 1.); apply_gt_gauge(gauge_trafo); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value after gauge trafo: %25.16e\n", plaq); } /**************************************** * allocate memory for the spinor fields ****************************************/ no_fields = 3; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /**************************************** * allocate memory for the contractions ****************************************/ disc = (double*)calloc( 8*VOLUME, sizeof(double)); if( disc == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(3); } for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; work = (double*)calloc(48*VOLUME, sizeof(double)); if( work == (double*)NULL ) { fprintf(stderr, "could not allocate memory for work\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(3); } /**************************************** * prepare Fourier transformation arrays ****************************************/ in = (fftw_complex*)malloc(FFTW_LOC_VOLUME*sizeof(fftw_complex)); if(in==(fftw_complex*)NULL) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(4); } /*********************************************** * start loop on source id.s ***********************************************/ for(sid=g_sourceid; sid<=g_sourceid2; sid++) { /******************************** * read the first propagator ********************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid); if(read_lime_spinor(g_spinor_field[2], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, Nconf, sid); if(read_cmi(g_spinor_field[2], filename) != 0) break; } xchange_field(g_spinor_field[2]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "time to read prop.: %e seconds\n", retime-ratime); if(do_gt==1) { /****************************************** * gauge transform the propagators for sid ******************************************/ for(ix=0; ix<VOLUME; ix++) { _fv_eq_cm_ti_fv(spinor1, gauge_trafo+18*ix, g_spinor_field[2]+_GSI(ix)); _fv_eq_fv(g_spinor_field[2]+_GSI(ix), spinor1); } xchange_field(g_spinor_field[2]); } /************************************************ * calculate the source: apply Q_phi_tbc ************************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_phi_tbc(g_spinor_field[0], g_spinor_field[2]); xchange_field(g_spinor_field[0]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "time to calculate source: %e seconds\n", retime-ratime); /************************************************ * HPE: apply BH5 ************************************************/ BH5(g_spinor_field[1], g_spinor_field[2]); for(ix=0; ix<8*VOLUME; ix++) {disc[ix] = 0.;} /* add new contractions to (existing) disc */ # ifdef MPI ratime = MPI_Wtime(); # else ratime = (double)clock() / CLOCKS_PER_SEC; # endif for(mu=0; mu<4; mu++) { /* loop on Lorentz index of the current */ iix = _GWI(mu,0,VOLUME); for(ix=0; ix<VOLUME; ix++) { /* loop on lattice sites */ _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix, mu)], &co_phase_up[mu]); /* first contribution */ _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(ix)], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; /* second contribution */ _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(g_iup[ix][mu])], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; iix += 2; } /* of ix */ } /* of mu */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "[%2d] time to contract cvc: %e seconds\n", g_cart_id, retime-ratime); #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /* Fourier transform data, copy to work */ for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(disc+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif memcpy((void*)(work+_GWI(mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } /******************************** * read the second propagator ********************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid+g_resume); if(read_lime_spinor(g_spinor_field[2], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, Nconf, sid+g_resume); if(read_cmi(g_spinor_field[2], filename) != 0) break; } xchange_field(g_spinor_field[2]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "time to read prop.: %e seconds\n", retime-ratime); if(do_gt==1) { /****************************************** * gauge transform the propagators for sid ******************************************/ for(ix=0; ix<VOLUME; ix++) { _fv_eq_cm_ti_fv(spinor1, gauge_trafo+18*ix, g_spinor_field[2]+_GSI(ix)); _fv_eq_fv(g_spinor_field[2]+_GSI(ix), spinor1); } xchange_field(g_spinor_field[2]); } /************************************************ * calculate the source: apply Q_phi_tbc ************************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_phi_tbc(g_spinor_field[0], g_spinor_field[2]); xchange_field(g_spinor_field[0]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "time to calculate source: %e seconds\n", retime-ratime); /************************************************ * HPE: apply BH5 ************************************************/ BH5(g_spinor_field[1], g_spinor_field[2]); for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; /* add new contractions to (existing) disc */ # ifdef MPI ratime = MPI_Wtime(); # else ratime = (double)clock() / CLOCKS_PER_SEC; # endif for(mu=0; mu<4; mu++) { /* loop on Lorentz index of the current */ iix = _GWI(mu,0,VOLUME); for(ix=0; ix<VOLUME; ix++) { /* loop on lattice sites */ _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix, mu)], &co_phase_up[mu]); /* first contribution */ _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(ix)], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; /* second contribution */ _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(g_iup[ix][mu])], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; iix += 2; } /* of ix */ } /* of mu */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "[%2d] time to contract cvc: %e seconds\n", g_cart_id, retime-ratime); #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /* Fourier transform data, copy to work */ for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(disc+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif memcpy((void*)(work+_GWI(4+mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } fnorm = 1. / ((double)(T_global*LX*LY*LZ)); fprintf(stdout, "fnorm = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(work+_GWI(mu,0,VOLUME)); cp2 = (complex*)(work+_GWI(4+nu,0,VOLUME)); cp3 = (complex*)(work+_GWI(8+4*mu+nu,0,VOLUME)); for(x0=0; x0<T; x0++) { q[0] = (double)(x0+Tstart) / (double)T_global; for(x1=0; x1<LX; x1++) { q[1] = (double)(x1) / (double)LX; for(x2=0; x2<LY; x2++) { q[2] = (double)(x2) / (double)LY; for(x3=0; x3<LZ; x3++) { q[3] = (double)(x3) / (double)LZ; ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * (q[mu]-q[nu]) ); w.im = sin( M_PI * (q[mu]-q[nu]) ); _co_eq_co_ti_co(&w1, cp1, cp2); _co_eq_co_ti_co(cp3, &w1, &w); _co_ti_eq_re(cp3, fnorm); cp1++; cp2++; cp3++; } } } } } } /* save the result in momentum space */ sprintf(filename, "cvc_hpe5_ft.%.4d.%.2d", Nconf, sid); write_contraction(work+_GWI(8,0,VOLUME), NULL, filename, 16, 0, 0); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "time to save cvc results: %e seconds\n", retime-ratime); } /* of loop on sid */ /*********************************************** * free the allocated memory, finalize ***********************************************/ free(g_gauge_field); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); fftw_free(in); free(disc); free(work); #ifdef MPI fftwnd_mpi_destroy_plan(plan_p); fftwnd_mpi_destroy_plan(plan_m); free(status); MPI_Finalize(); #else fftwnd_destroy_plan(plan_p); fftwnd_destroy_plan(plan_m); #endif return(0); }
/* for ieo=0, k resides on odd sites and l on even sites */ void Hopping_Matrix(int ieo, spinor * const l, spinor * const k){ int ix,iy; int ioff,ioff2,icx,icy; su3 * restrict up, * restrict um; spinor * restrict r, * restrict sp, * restrict sm; spinor temp; #ifdef _GAUGE_COPY if(g_update_gauge_copy) { update_backward_gauge(); } #endif /* for parallelization */ # if (defined MPI && !(defined _NO_COMM)) xchange_field(k, ieo); # endif if(k == l){ printf("Error in H_psi (simple.c):\n"); printf("Arguments k and l must be different\n"); printf("Program aborted\n"); exit(1); } if(ieo == 0){ ioff = 0; } else{ ioff = (VOLUME+RAND)/2; } ioff2 = (VOLUME+RAND)/2-ioff; /**************** loop over all lattice sites ****************/ for (icx = ioff; icx < (VOLUME/2 + ioff); icx++){ ix=g_eo2lexic[icx]; r=l+(icx-ioff); /*********************** direction +0 ************************/ iy=g_iup[ix][0]; icy=g_lexic2eosub[iy]; sp=k+icy; # if ((defined _GAUGE_COPY)) up=&g_gauge_field_copy[icx][0]; # else up=&g_gauge_field[ix][0]; # endif _vector_add(psi,(*sp).s0,(*sp).s2); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka0,chi); _vector_assign(temp.s0,psi); _vector_assign(temp.s2,psi); _vector_add(psi,(*sp).s1,(*sp).s3); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka0,chi); _vector_assign(temp.s1,psi); _vector_assign(temp.s3,psi); /*********************** direction -0 ************************/ iy=g_idn[ix][0]; icy=g_lexic2eosub[iy]; sm=k+icy; # if ((defined _GAUGE_COPY)) um = up+1; # else um=&g_gauge_field[iy][0]; # endif _vector_sub(psi,(*sm).s0,(*sm).s2); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka0,chi); _vector_add_assign(temp.s0,psi); _vector_sub_assign(temp.s2,psi); _vector_sub(psi,(*sm).s1,(*sm).s3); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka0,chi); _vector_add_assign(temp.s1,psi); _vector_sub_assign(temp.s3,psi); /*********************** direction +1 ************************/ iy=g_iup[ix][1]; icy=g_lexic2eosub[iy]; sp=k+icy; # if ((defined _GAUGE_COPY)) up=um+1; # else up+=1; # endif _vector_i_add(psi,(*sp).s0,(*sp).s3); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka1,chi); _vector_add_assign(temp.s0,psi); _vector_i_sub_assign(temp.s3,psi); _vector_i_add(psi,(*sp).s1,(*sp).s2); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka1,chi); _vector_add_assign(temp.s1,psi); _vector_i_sub_assign(temp.s2,psi); /*********************** direction -1 ************************/ iy=g_idn[ix][1]; icy=g_lexic2eosub[iy]; sm=k+icy; # ifndef _GAUGE_COPY um=&g_gauge_field[iy][1]; # else um=up+1; # endif _vector_i_sub(psi,(*sm).s0,(*sm).s3); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka1,chi); _vector_add_assign(temp.s0,psi); _vector_i_add_assign(temp.s3,psi); _vector_i_sub(psi,(*sm).s1,(*sm).s2); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka1,chi); _vector_add_assign(temp.s1,psi); _vector_i_add_assign(temp.s2,psi); /*********************** direction +2 ************************/ iy=g_iup[ix][2]; icy=g_lexic2eosub[iy]; sp=k+icy; # if ((defined _GAUGE_COPY)) up=um+1; # else up+=1; # endif _vector_add(psi,(*sp).s0,(*sp).s3); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka2,chi); _vector_add_assign(temp.s0,psi); _vector_add_assign(temp.s3,psi); _vector_sub(psi,(*sp).s1,(*sp).s2); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka2,chi); _vector_add_assign(temp.s1,psi); _vector_sub_assign(temp.s2,psi); /*********************** direction -2 ************************/ iy=g_idn[ix][2]; icy=g_lexic2eosub[iy]; sm=k+icy; # ifndef _GAUGE_COPY um = &g_gauge_field[iy][2]; # else um = up +1; # endif _vector_sub(psi,(*sm).s0,(*sm).s3); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka2,chi); _vector_add_assign(temp.s0,psi); _vector_sub_assign(temp.s3,psi); _vector_add(psi,(*sm).s1,(*sm).s2); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka2,chi); _vector_add_assign(temp.s1,psi); _vector_add_assign(temp.s2,psi); /*********************** direction +3 ************************/ iy=g_iup[ix][3]; icy=g_lexic2eosub[iy]; sp=k+icy; # if ((defined _GAUGE_COPY)) up=um+1; # else up+=1; # endif _vector_i_add(psi,(*sp).s0,(*sp).s2); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka3,chi); _vector_add_assign(temp.s0,psi); _vector_i_sub_assign(temp.s2,psi); _vector_i_sub(psi,(*sp).s1,(*sp).s3); _su3_multiply(chi,(*up),psi); _complex_times_vector(psi,ka3,chi); _vector_add_assign(temp.s1,psi); _vector_i_add_assign(temp.s3,psi); /*********************** direction -3 ************************/ iy=g_idn[ix][3]; icy=g_lexic2eosub[iy]; sm=k+icy; # ifndef _GAUGE_COPY um = &g_gauge_field[iy][3]; # else um = up+1; # endif _vector_i_sub(psi,(*sm).s0,(*sm).s2); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka3,chi); _vector_add((*r).s0, temp.s0, psi); _vector_i_add((*r).s2, temp.s2, psi); _vector_i_add(psi,(*sm).s1,(*sm).s3); _su3_inverse_multiply(chi,(*um),psi); _complexcjg_times_vector(psi,ka3,chi); _vector_add((*r).s1, temp.s1, psi); _vector_i_sub((*r).s3, temp.s3, psi); /************************ end of loop ************************/ } }
int main(int argc, char **argv) { int c, i, j, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix, iix, it; int sid, status, gid; double **corr=NULL, **corr2=NULL; double *tcorr=NULL, *tcorr2=NULL; double *work = (double*)NULL; double q[4], fnorm; int verbose = 0; int do_gt = 0; int nsource=0; char filename[100], contype[200]; double ratime, retime; double plaq; double spinor1[24], spinor2[24], U_[18]; double *gauge_trafo=(double*)NULL; double mom2, mom4; complex w, w1, *cp1, *cp2, *cp3; FILE *ofs; #ifdef MPI // MPI_Init(&argc, &argv); fprintf(stderr, "[jc_ud_x] Error, only non-mpi version implemented\n"); exit(1); #endif while ((c = getopt(argc, argv, "h?f:")) != -1) { switch (c) { case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# Reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } fprintf(stdout, "\n**************************************************\n"); fprintf(stdout, "* jc_ud_x\n"); fprintf(stdout, "**************************************************\n\n"); /********************************* * initialize MPI parameters *********************************/ // mpi_init(argc, argv); /* initialize */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; fprintf(stdout, "# [%2d] parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); exit(1); } geometry(); /************************************************* * allocate mem for gauge field and spinor fields *************************************************/ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); no_fields = 2; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /**************************************** * allocate memory for the contractions ****************************************/ nsource = (g_sourceid2 - g_sourceid + 1) / g_sourceid_step; if(g_cart_id==0) fprintf(stdout, "# nsource = %d\n", nsource); corr = (double**)calloc( nsource, sizeof(double*)); corr[0] = (double*)calloc( nsource*T*8, sizeof(double)); for(i=1;i<nsource;i++) corr[i] = corr[i-1] + 8*T; corr2 = (double**)calloc( nsource, sizeof(double*)); corr2[0] = (double*)calloc( nsource*8*T, sizeof(double)); for(i=1;i<nsource;i++) corr2[i] = corr2[i-1] + 8*T; tcorr = (double*)calloc(T*8, sizeof(double)); tcorr2 = (double*)calloc(T*8, sizeof(double)); /*********************************************** * start loop on gauge id.s ***********************************************/ for(gid=g_gaugeid; gid<=g_gaugeid2; gid++) { sprintf(filename, "%s.%.4d", gaugefilename_prefix, gid); if(g_cart_id==0) fprintf(stdout, "# reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "# measured plaquette value: %25.16e\n", plaq); /* reset disc to zero */ for(ix=0; ix<nsource*8*T; ix++) corr[0][ix] = 0.; for(ix=0; ix<nsource*8*T; ix++) corr2[0][ix] = 0.; count=0; /*********************************************** * start loop on source id.s ***********************************************/ for(sid=g_sourceid; sid<=g_sourceid2; sid+=g_sourceid_step) { /* read the new propagator to g_spinor_field[0] */ ratime = (double)clock() / CLOCKS_PER_SEC; if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, gid, sid); if(read_lime_spinor(g_spinor_field[0], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, gid, sid); if(read_cmi(g_spinor_field[0], filename) != 0) { fprintf(stderr, "\nError from read_cmi\n"); break; } } xchange_field(g_spinor_field[0]); retime = (double)clock() / CLOCKS_PER_SEC; if(g_cart_id==0) fprintf(stdout, "# time to read prop.: %e seconds\n", retime-ratime); ratime = (double)clock() / CLOCKS_PER_SEC; /* apply [1] = D_tm [0] */ Q_phi_tbc(g_spinor_field[1], g_spinor_field[0]); xchange_field(g_spinor_field[1]); retime = (double)clock() / CLOCKS_PER_SEC; if(g_cart_id==0) fprintf(stdout, "# time to apply D_W: %e seconds\n", retime-ratime); ratime = (double)clock() / CLOCKS_PER_SEC; /* calculate real and imaginary part */ for(mu=0; mu<4; mu++) { for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { ix = g_ipt[x0][x1][x2][x3]; _cm_eq_cm_ti_co(U_, g_gauge_field+_GGI(ix,mu), &(co_phase_up[mu])); _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[0][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[1][_GSI(ix)], spinor2); corr[count][2*(mu*T+x0) ] -= 0.5*w.re; corr[count][2*(mu*T+x0)+1] -= 0.5*w.im; _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[0][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[1][_GSI(g_iup[ix][mu])], spinor2); corr[count][2*(mu*T+x0) ] -= 0.5*w.re; corr[count][2*(mu*T+x0)+1] -= 0.5*w.im; _fv_eq_gamma_ti_fv(spinor1, mu, &g_spinor_field[0][_GSI(ix)]); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[1][_GSI(ix)], spinor1); corr2[count][2*(mu*T+x0) ] -= w.re; corr2[count][2*(mu*T+x0)+1] -= w.im; }}} } } // of mu count++; } // of sid retime = (double)clock() / CLOCKS_PER_SEC; if(g_cart_id==0) fprintf(stdout, "# time to calculate contractions: %e seconds\n", retime-ratime); for(ix=0;ix<8*T;ix++) tcorr[ix] = 0.; for(ix=0;ix<8*T;ix++) tcorr2[ix] = 0.; for(i=0;i<nsource-1;i++) { for(j=i+1;j<nsource;j++) { for(mu=0;mu<4;mu++) { for(x0=0;x0<T;x0++) { // times at source for(x1=0;x1<T;x1++) { // times at sink it = (x1 - x0 + T) % T; // conserved current tcorr[2*(mu*T+it) ] += corr[i][2*(mu*T+x1)] * corr[j][2*(mu*T+x0) ] - corr[i][2*(mu*T+x1)+1] * corr[j][2*(mu*T+x0)+1]; tcorr[2*(mu*T+it)+1] += corr[i][2*(mu*T+x1)] * corr[j][2*(mu*T+x0)+1] + corr[i][2*(mu*T+x1)+1] * corr[j][2*(mu*T+x0) ]; tcorr[2*(mu*T+it) ] += corr[j][2*(mu*T+x1)] * corr[i][2*(mu*T+x0) ] - corr[j][2*(mu*T+x1)+1] * corr[i][2*(mu*T+x0)+1]; tcorr[2*(mu*T+it)+1] += corr[j][2*(mu*T+x1)] * corr[i][2*(mu*T+x0)+1] + corr[j][2*(mu*T+x1)+1] * corr[i][2*(mu*T+x0) ]; // local current tcorr2[2*(mu*T+it) ] += corr2[i][2*(mu*T+x1)] * corr2[j][2*(mu*T+x0) ] - corr2[i][2*(mu*T+x1)+1] * corr2[j][2*(mu*T+x0)+1]; tcorr2[2*(mu*T+it)+1] += corr2[i][2*(mu*T+x1)] * corr2[j][2*(mu*T+x0)+1] + corr2[i][2*(mu*T+x1)+1] * corr2[j][2*(mu*T+x0) ]; tcorr2[2*(mu*T+it) ] += corr2[j][2*(mu*T+x1)] * corr2[i][2*(mu*T+x0) ] - corr2[j][2*(mu*T+x1)+1] * corr2[i][2*(mu*T+x0)+1]; tcorr2[2*(mu*T+it)+1] += corr2[j][2*(mu*T+x1)] * corr2[i][2*(mu*T+x0)+1] + corr2[j][2*(mu*T+x1)+1] * corr2[i][2*(mu*T+x0) ]; }} } }} fnorm = 1. / ( g_prop_normsqr * g_prop_normsqr * (double)(LX*LY*LZ) * (double)(LX*LY*LZ) * nsource * (nsource-1)); if(g_cart_id==0) fprintf(stdout, "X-fnorm = %e\n", fnorm); for(ix=0;ix<8*T;ix++) tcorr[ix] *= fnorm; for(ix=0;ix<8*T;ix++) tcorr2[ix] *= fnorm; /************************************************ * save results ************************************************/ if(g_cart_id == 0) fprintf(stdout, "# save results for gauge id %d and sid %d\n", gid, sid); /* save the result in position space */ sprintf(filename, "jc_u_tp0.%.4d.%.4d", gid, sid); ofs = fopen(filename, "w"); for(x0=0;x0<T;x0++) fprintf(ofs, "%d%25.16e%25.16e%25.16e%25.16e%25.16e%25.16e%25.16e%25.16e\n", x0, tcorr[2*(0*T+x0)], tcorr[2*(0*T+x0)+1], tcorr[2*(1*T+x0)], tcorr[2*(1*T+x0)+1], tcorr[2*(2*T+x0)], tcorr[2*(2*T+x0)+1], tcorr[2*(3*T+x0)], tcorr[2*(3*T+x0)+1]); fclose(ofs); } /* of loop on gid */ /*********************************************** * free the allocated memory, finalize ***********************************************/ free(g_gauge_field); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); free(corr); free(corr2); free(tcorr); free(tcorr2); return(0); }
int main(int argc, char **argv) { int c, i, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix, iix; int sid, status, gid; double *disc = (double*)NULL; double *work = (double*)NULL; double q[4], fnorm; int verbose = 0; int do_gt = 0; char filename[100], contype[200]; double ratime, retime; double plaq; double spinor1[24], spinor2[24], U_[18]; double *gauge_trafo=(double*)NULL; complex w, w1, *cp1, *cp2, *cp3; FILE *ofs; #ifdef MPI // MPI_Init(&argc, &argv); fprintf(stderr, "[jc_ud_x] Error, only non-mpi version implemented\n"); exit(1); #endif while ((c = getopt(argc, argv, "h?f:")) != -1) { switch (c) { case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# Reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } fprintf(stdout, "\n**************************************************\n"); fprintf(stdout, "* jc_ud_x\n"); fprintf(stdout, "**************************************************\n\n"); /********************************* * initialize MPI parameters *********************************/ // mpi_init(argc, argv); /* initialize fftw */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; fprintf(stdout, "# [%2d] parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); exit(1); } geometry(); /************************************************* * allocate mem for gauge field and spinor fields *************************************************/ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); no_fields = 2; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /**************************************** * allocate memory for the contractions ****************************************/ disc = (double*)calloc( 8*VOLUME, sizeof(double)); if( disc == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); exit(3); } /*********************************************** * start loop on gauge id.s ***********************************************/ for(gid=g_gaugeid; gid<=g_gaugeid2; gid++) { for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; sprintf(filename, "%s.%.4d", gaugefilename_prefix, gid); if(g_cart_id==0) fprintf(stdout, "# reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "# measured plaquette value: %25.16e\n", plaq); /*********************************************** * start loop on source id.s ***********************************************/ for(sid=g_sourceid; sid<=g_sourceid2; sid+=g_sourceid_step) { /* reset disc to zero */ for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; /* read the new propagator to g_spinor_field[0] */ ratime = (double)clock() / CLOCKS_PER_SEC; if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, gid, sid); if(read_lime_spinor(g_spinor_field[0], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, gid, sid); if(read_cmi(g_spinor_field[0], filename) != 0) break; } xchange_field(g_spinor_field[0]); retime = (double)clock() / CLOCKS_PER_SEC; if(g_cart_id==0) fprintf(stdout, "# time to read prop.: %e seconds\n", retime-ratime); ratime = (double)clock() / CLOCKS_PER_SEC; /* apply D_W once, save in g_spinor_field[1] */ Hopping(g_spinor_field[1], g_spinor_field[0]); for(ix=0; ix<VOLUME; ix++) { _fv_pl_eq_fv(g_spinor_field[1]+_GSI(ix), g_spinor_field[0]+_GSI(ix)); _fv_ti_eq_re(g_spinor_field[1]+_GSI(ix), 1./(2.*g_kappa)); } xchange_field(g_spinor_field[1]); retime = (double)clock() / CLOCKS_PER_SEC; if(g_cart_id==0) fprintf(stdout, "# time to apply D_W: %e seconds\n", retime-ratime); ratime = (double)clock() / CLOCKS_PER_SEC; /* calculate real and imaginary part */ for(mu=0; mu<4; mu++) { for(ix=0; ix<VOLUME; ix++) { _cm_eq_cm_ti_co(U_, g_gauge_field+_GGI(ix,mu), &(co_phase_up[mu])); _fv_eq_gamma_ti_fv(spinor1, 5, g_spinor_field[0]+_GSI(g_iup[ix][mu])); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _fv_eq_cm_ti_fv(spinor1, U_, spinor2); _co_eq_fv_dag_ti_fv(&w, g_spinor_field[0]+_GSI(ix), spinor1); disc[_GWI(mu,ix,VOLUME) ] = g_mu * w.im; _fv_eq_gamma_ti_fv(spinor1, mu, g_spinor_field[1]+_GSI(g_iup[ix][mu])); _fv_pl_eq_fv(spinor1, g_spinor_field[1]+_GSI(g_iup[ix][mu])); _fv_eq_cm_ti_fv(spinor2, U_, spinor1); _co_eq_fv_dag_ti_fv(&w, g_spinor_field[0]+_GSI(ix), spinor2); disc[_GWI(mu,ix,VOLUME)+1] = w.im / 3.; } } retime = (double)clock() / CLOCKS_PER_SEC; if(g_cart_id==0) fprintf(stdout, "# time to calculate contractions: %e seconds\n", retime-ratime); /************************************************ * save results ************************************************/ if(g_cart_id == 0) fprintf(stdout, "# save results for gauge id %d and sid %d\n", gid, sid); /* save the result in position space */ fnorm = 1. / g_prop_normsqr; if(g_cart_id==0) fprintf(stdout, "X-fnorm = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(ix=0; ix<VOLUME; ix++) { disc[_GWI(mu,ix,VOLUME) ] *= fnorm; disc[_GWI(mu,ix,VOLUME)+1] *= fnorm; } } sprintf(filename, "jc_ud_x.%.4d.%.4d", gid, sid); sprintf(contype, "jc-u_and_d-X"); write_lime_contraction(disc, filename, 64, 4, contype, gid, sid); //sprintf(filename, "jc_ud_x.%.4d.%.4d.ascii", gid, sid); //write_contraction (disc, NULL, filename, 4, 2, 0); } /* of loop on sid */ } /* of loop on gid */ /*********************************************** * free the allocated memory, finalize ***********************************************/ free(g_gauge_field); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); free(disc); return(0); }
int main(int argc, char **argv) { int c, i, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix, iix; int sid, status; double *disc = (double*)NULL; double *data = (double*)NULL; double *bias = (double*)NULL; double *work = (double*)NULL; double q[4], fnorm; int verbose = 0; char filename[100], contype[200]; double ratime, retime; double plaq; double spinor1[24], spinor2[24], U_[18]; complex w, w1, *cp1, *cp2, *cp3, *cp4; fftw_complex *in=(fftw_complex*)NULL; #ifdef MPI fftwnd_mpi_plan plan_p, plan_m; #else fftwnd_plan plan_p, plan_m; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# Reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa <= 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.\n"); usage(); } if(hpe_order%2==0 && hpe_order>0) { if(g_proc_id==0) fprintf(stdout, "HPE order should be odd\n"); usage(); } fprintf(stdout, "\n**************************************************\n"\ "* vp_disc_hpe_stoch_subtract with HPE of order %d\n"\ "**************************************************\n\n", hpe_order); /********************************* * initialize MPI parameters *********************************/ mpi_init(argc, argv); /* initialize fftw */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; #ifdef MPI plan_p = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_BACKWARD, FFTW_MEASURE); plan_m = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_FORWARD, FFTW_MEASURE); fftwnd_mpi_local_sizes(plan_p, &T, &Tstart, &l_LX_at, &l_LXstart_at, &FFTW_LOC_VOLUME); #else plan_p = fftwnd_create_plan(4, dims, FFTW_BACKWARD, FFTW_MEASURE | FFTW_IN_PLACE); plan_m = fftwnd_create_plan(4, dims, FFTW_FORWARD, FFTW_MEASURE | FFTW_IN_PLACE); T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; #endif fprintf(stdout, "# [%2d] fftw parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); #ifdef MPI if(T==0) { fprintf(stderr, "[%2d] local T is zero; exit\n", g_cart_id); MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(101); } #endif if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(102); } geometry(); /************************************************ * read the gauge field, measure the plaquette ************************************************/ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "# reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "# measured plaquette value: %25.16e\n", plaq); /**************************************** * allocate memory for the spinor fields ****************************************/ no_fields = 3; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /**************************************** * allocate memory for the contractions ****************************************/ disc = (double*)calloc(16*VOLUME, sizeof(double)); if( disc == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(103); } data = (double*)calloc(16*VOLUME, sizeof(double)); if( data== (double*)NULL ) { fprintf(stderr, "could not allocate memory for data\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(104); } for(ix=0; ix<16*VOLUME; ix++) data[ix] = 0.; work = (double*)calloc(32*VOLUME, sizeof(double)); if( work == (double*)NULL ) { fprintf(stderr, "could not allocate memory for work\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(105); } bias = (double*)calloc(32*VOLUME, sizeof(double)); if( bias == (double*)NULL ) { fprintf(stderr, "could not allocate memory for bias\n"); # ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); # endif exit(106); } for(ix=0; ix<32*VOLUME; ix++) bias[ix] = 0.; /**************************************** * prepare Fourier transformation arrays ****************************************/ in = (fftw_complex*)malloc(FFTW_LOC_VOLUME*sizeof(fftw_complex)); if(in==(fftw_complex*)NULL) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(107); } /*********************************************** * start loop on source id.s ***********************************************/ for(sid=g_sourceid; sid<=g_sourceid2; sid+=g_sourceid_step) { for(ix=0; ix<16*VOLUME; ix++) disc[ix] = 0.; /* read the new propagator */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid); if(read_lime_spinor(g_spinor_field[2], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, Nconf, sid); if(read_cmi(g_spinor_field[2], filename) != 0) break; } xchange_field(g_spinor_field[2]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to read prop.: %e seconds\n", retime-ratime); count++; /************************************************ * calculate the source: apply Q_phi_tbc ************************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_phi_tbc(g_spinor_field[0], g_spinor_field[2]); xchange_field(g_spinor_field[0]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to calculate source: %e seconds\n", retime-ratime); #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /************************************************ * HPE: apply BH to order hpe_order+2 ************************************************/ if(hpe_order>0) { BHn(g_spinor_field[1], g_spinor_field[2], hpe_order+2); } else { memcpy((void*)g_spinor_field[1], (void*)g_spinor_field[2], 24*VOLUMEPLUSRAND*sizeof(double)); } /************************************************ * add new contractions to (existing) disc ************************************************/ for(mu=0; mu<4; mu++) { iix = _GWI(mu,0,VOLUME); for(ix=0; ix<VOLUME; ix++) { _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix, mu)], &co_phase_up[mu]); _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(ix)], spinor2); disc[iix ] = -0.5 * w.re; disc[iix+1] = -0.5 * w.im; data[iix ] -= 0.5 * w.re; data[iix+1] -= 0.5 * w.im; _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(g_iup[ix][mu])], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; data[iix ] -= 0.5 * w.re; data[iix+1] -= 0.5 * w.im; iix += 2; } } #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to contract cvc: %e seconds\n", retime-ratime); #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(disc+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif memcpy((void*)(disc+_GWI(4+mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); memcpy((void*)in, (void*)(disc+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif memcpy((void*)(disc+_GWI(mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } /* of mu =0 ,..., 3*/ for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(disc+_GWI(mu, 0,VOLUME)); cp2 = (complex*)(disc+_GWI(4+nu, 0,VOLUME)); cp3 = (complex*)(bias+_GWI(4*mu+nu,0,VOLUME)); for(ix=0; ix<VOLUME; ix++) { _co_eq_co_ti_co(&w1, cp1, cp2); cp3->re += w1.re; cp3->im += w1.im; cp1++; cp2++; cp3++; } }} #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time for Fourier trafo and adding to bias: %e seconds\n", retime-ratime); } /* of loop on sid */ /************************************************ * save results for count == Nsave ************************************************/ if(count==Nsave) { if(g_cart_id == 0) fprintf(stdout, "# save results for count = %d\n", count); for(ix=0; ix<16*VOLUME; ix++) disc[ix] = 0.; if(hpe_order>0) { sprintf(filename, "vp_disc_hpe%.2d_loops_X.%.4d", hpe_order, Nconf); if(g_cart_id==0) fprintf(stdout, "# reading loop part from file %s\n", filename); if( (status = read_lime_contraction(disc, filename, 4, 0)) != 0 ) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(108); } } /* save the result in position space */ fnorm = 1. / ( (double)count * g_prop_normsqr ); if(g_cart_id==0) fprintf(stdout, "# X-fnorm = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(ix=0; ix<VOLUME; ix++) { work[_GWI(mu,ix,VOLUME) ] = data[_GWI(mu,ix,VOLUME) ] * fnorm + disc[_GWI(mu,ix,VOLUME) ]; work[_GWI(mu,ix,VOLUME)+1] = data[_GWI(mu,ix,VOLUME)+1] * fnorm + disc[_GWI(mu,ix,VOLUME)+1]; } } sprintf(filename, "vp_disc_hpe%.2d_subtracted_X.%.4d.%.4d", hpe_order, Nconf, count); sprintf(contype, "cvc-disc-hpe-loops-%2d-to-%2d-stoch-subtracted-X", hpe_order, hpe_order+2); write_lime_contraction(work, filename, 64, 4, contype, Nconf, count); /* sprintf(filename, "vp_disc_hpe%.2d_subtracted_X.%.4d.%.4d.ascii", hpe_order, Nconf, count); write_contraction(work, NULL, filename, 4, 2, 0); */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(data+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif memcpy((void*)(data+_GWI(4+mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); memcpy((void*)in, (void*)(data+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif memcpy((void*)(data+_GWI(mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } fnorm = 1. / ( g_prop_normsqr*g_prop_normsqr * (double)count * (double)(count-1) ); if(g_cart_id==0) fprintf(stdout, "# P-fnorm for purely stochastic part = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(data+_GWI(mu, 0,VOLUME)); cp2 = (complex*)(data+_GWI(4+nu, 0,VOLUME)); cp3 = (complex*)(work+_GWI(4*mu+nu,0,VOLUME)); cp4 = (complex*)(bias+_GWI(4*mu+nu,0,VOLUME)); for(ix=0; ix<VOLUME; ix++) { _co_eq_co_ti_co(&w1, cp1, cp2); cp3->re = ( w1.re - cp4->re ) * fnorm; cp3->im = ( w1.im - cp4->im ) * fnorm; cp1++; cp2++; cp3++; cp4++; } }} for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(disc+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif memcpy((void*)(disc+_GWI(4+mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); memcpy((void*)in, (void*)(disc+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif memcpy((void*)(disc+_GWI(mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } fnorm = 1. / ( g_prop_normsqr * (double)count ); if(g_cart_id==0) fprintf(stdout, "# P-fnorm for mixed stochastic-loop part = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(data + _GWI(mu, 0,VOLUME)); cp2 = (complex*)(disc + _GWI(4+nu, 0,VOLUME)); cp3 = (complex*)(work + _GWI(4*mu+nu,0,VOLUME)); for(ix=0; ix<VOLUME; ix++) { _co_eq_co_ti_co(&w1, cp1, cp2); cp3->re += w1.re * fnorm; cp3->im += w1.im * fnorm; cp1++; cp2++; cp3++; } cp1 = (complex*)(disc + _GWI(mu, 0,VOLUME)); cp2 = (complex*)(data + _GWI(4+nu, 0,VOLUME)); cp3 = (complex*)(work + _GWI(4*mu+nu,0,VOLUME)); for(ix=0; ix<VOLUME; ix++) { _co_eq_co_ti_co(&w1, cp1, cp2); cp3->re += w1.re * fnorm; cp3->im += w1.im * fnorm; cp1++; cp2++; cp3++; } }} fnorm = 1. / ( (double)T_global * (double)(LX*LY*LZ) ); if(g_cart_id==0) fprintf(stdout, "# P-fnorm for final estimator (1/T/V) = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(disc + _GWI(mu, 0,VOLUME)); cp2 = (complex*)(disc + _GWI(4+nu, 0,VOLUME)); cp3 = (complex*)(work + _GWI(4*mu+nu,0,VOLUME)); for(x0=0; x0<T; x0++) { q[0] = (double)(x0+Tstart) / (double)T_global; for(x1=0; x1<LX; x1++) { q[1] = (double)x1 / (double)LX; for(x2=0; x2<LY; x2++) { q[2] = (double)x2 / (double)LY; for(x3=0; x3<LZ; x3++) { q[3] = (double)x3 / (double)LZ; ix = g_ipt[x0][x1][x2][x3]; w.re = cos(M_PI * ( q[mu] - q[nu] ) ); w.im = sin(M_PI * ( q[mu] - q[nu] ) ); _co_eq_co_ti_co(&w1, cp1, cp2); cp3->re += w1.re; cp3->im += w1.im; _co_eq_co_ti_co(&w1, cp3, &w); cp3->re = w1.re * fnorm; cp3->im = w1.im * fnorm; cp1++; cp2++; cp3++; }}}} }} sprintf(filename, "vp_disc_hpe%.2d_subtracted_P.%.4d.%.4d", hpe_order, Nconf, count); sprintf(contype, "cvc-disc-hpe-loops-%2d-to-%2d-stoch-subtracted-P", hpe_order, hpe_order+2); write_lime_contraction(work, filename, 64, 16, contype, Nconf, count); /* sprintf(filename, "vp_disc_hpe%.2d_subtracted_P.%.4d.%.4d.ascii", hpe_order, Nconf, count); write_contraction(work, NULL, filename, 16, 2, 0); */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to save cvc results: %e seconds\n", retime-ratime); } /* of if count == Nsave */ /*********************************************** * free the allocated memory, finalize ***********************************************/ free(g_gauge_field); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); fftw_free(in); free(disc); free(bias); free(data); free(work); #ifdef MPI fftwnd_mpi_destroy_plan(plan_p); fftwnd_mpi_destroy_plan(plan_m); MPI_Finalize(); #else fftwnd_destroy_plan(plan_p); fftwnd_destroy_plan(plan_m); #endif return(0); }
int main(int argc, char **argv) { int c, i, mu; int count = 0; int filename_set = 0; int l_LX_at, l_LXstart_at; int x0, x1, ix, idx; int VOL3; int sid; double *disc = (double*)NULL; int verbose = 0; char filename[100]; double ratime, retime; double plaq; double spinor1[24], spinor2[24]; double _2kappamu; double *gauge_field_f=NULL, *gauge_field_timeslice=NULL; double v4norm = 0., vvnorm = 0.; complex w; FILE *ofs1, *ofs2; /* double sign_adj5[] = {-1., -1., -1., -1., +1., +1., +1., +1., +1., +1., -1., -1., -1., 1., -1., -1.}; */ double hopexp_coeff[8], addreal, addimag; int gindex[] = { 5 , 1 , 2 , 3 , 6 ,10 ,11 ,12 , 4 , 7 , 8 , 9 , 0 ,15 , 14 ,13 }; int isimag[] = { 0 , 0 , 0 , 0 , 1 , 1 , 1 , 1 , 0 , 1 , 1 , 1 , 0 , 1 , 1 , 1 }; double gsign[] = {-1., 1., 1., 1., -1., 1., 1., 1., 1., 1., 1., 1., 1., 1., -1., 1.}; #ifdef MPI MPI_Status status; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vgf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); #ifdef MPI T = T_global / g_nproc; Tstart = g_cart_id * T; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; VOL3 = LX*LY*LZ; #else T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; VOL3 = LX*LY*LZ; #endif fprintf(stdout, "# [%2d] parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); /* read the gauge field */ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); /* measure the plaquette */ plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "# measured plaquette value: %25.16e\n", plaq); if(Nlong > -1) { /* N_ape = 5; */ alpha_ape = 0.4; if(g_cart_id==0) fprintf(stdout, "# apply fuzzing of gauge field and propagators with parameters:\n"\ "# Nlong = %d\n# N_ape = %d\n# alpha_ape = %f\n", Nlong, N_ape, alpha_ape); alloc_gauge_field(&gauge_field_f, VOLUMEPLUSRAND); if( (gauge_field_timeslice = (double*)malloc(72*VOL3*sizeof(double))) == (double*)NULL ) { fprintf(stderr, "Error, could not allocate mem for gauge_field_timeslice\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(2); } for(x0=0; x0<T; x0++) { memcpy((void*)gauge_field_timeslice, (void*)(g_gauge_field+_GGI(g_ipt[x0][0][0][0],0)), 72*VOL3*sizeof(double)); for(i=0; i<N_ape; i++) { APE_Smearing_Step_Timeslice(gauge_field_timeslice, alpha_ape); } fuzzed_links_Timeslice(gauge_field_f, gauge_field_timeslice, Nlong, x0); } free(gauge_field_timeslice); } /* test: print the fuzzed APE smeared gauge field to stdout */ /* for(ix=0; ix<36*VOLUME; ix++) { fprintf(stdout, "%6d%25.16e%25.16e%25.16e%25.16e\n", ix, gauge_field_f[2*ix], gauge_field_f[2*ix+1], g_gauge_field[2*ix], g_gauge_field[2*ix+1]); } */ /* allocate memory for the spinor fields */ no_fields = 4; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /* allocate memory for the contractions */ disc = (double*)calloc(4*16*T*2, sizeof(double)); if( disc==(double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(3); } for(ix=0; ix<4*32*T; ix++) disc[ix] = 0.; if(g_cart_id==0) { sprintf(filename, "cvc_2pt_disc_vv.%.4d", Nconf); ofs1 = fopen(filename, "w"); sprintf(filename, "cvc_2pt_disc_v4.%.4d", Nconf); ofs2 = fopen(filename, "w"); if(ofs1==(FILE*)NULL || ofs2==(FILE*)NULL) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(5); } } /* add the HPE coefficients */ if(format==1) { addimag = 2*g_kappa*g_mu/sqrt(1 + 4*g_kappa*g_kappa*g_mu*g_mu)* LX*LY*LZ*3*4*2.*g_kappa*g_kappa*4; addreal = 1./sqrt(1 + 4*g_kappa*g_kappa*g_mu*g_mu)*LX*LY*LZ*3*4*2.*g_kappa*g_kappa*4; v4norm = 1. / ( 8. * g_kappa * g_kappa ); vvnorm = g_mu / ( 4. * g_kappa ); } else { addimag = 2*g_kappa*g_mu/sqrt(1 + 4*g_kappa*g_kappa*g_mu*g_mu)* LX*LY*LZ*3*4*2.*g_kappa*2; addreal = 1./sqrt(1 + 4*g_kappa*g_kappa*g_mu*g_mu)*LX*LY*LZ*3*4*2.*g_kappa*2; v4norm = 1. / ( 4. * g_kappa ); vvnorm = g_mu / ( 4. * g_kappa ); } /* calculate additional contributions for 1 and gamma_5 */ _2kappamu = 2.*g_kappa*g_mu; hopexp_coeff[0] = 24. * g_kappa * LX*LY*LZ / (1. + _2kappamu*_2kappamu); hopexp_coeff[1] = 0.; hopexp_coeff[2] = -768. * g_kappa*g_kappa*g_kappa * LX*LY*LZ * _2kappamu*_2kappamu / ( (1.+_2kappamu*_2kappamu)*(1.+_2kappamu*_2kappamu)*(1.+_2kappamu*_2kappamu) ); hopexp_coeff[3] = 0.; hopexp_coeff[4] = 0.; hopexp_coeff[5] = -24.*g_kappa * LX*LY*LZ * _2kappamu / (1. + _2kappamu*_2kappamu); hopexp_coeff[6] = 0.; hopexp_coeff[7] = -384. * g_kappa*g_kappa*g_kappa * LX*LY*LZ * (1.-_2kappamu*_2kappamu)*_2kappamu / ( (1.+_2kappamu*_2kappamu)*(1.+_2kappamu*_2kappamu)*(1.+_2kappamu*_2kappamu) ); /* start loop on source id.s */ for(sid=g_sourceid; sid<=g_sourceid2; sid+=g_sourceid_step) { for(ix=0; ix<4*32*T; ix++) disc[ix] = 0.; /* read the new propagator */ sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, Nconf, sid); /* sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid); */ if(read_lime_spinor(g_spinor_field[1], filename, 0) != 0) { fprintf(stderr, "[%2d] Error, could not read from file %s\n", g_cart_id, filename); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(4); } count++; xchange_field(g_spinor_field[1]); /* calculate the source: apply Q_phi_tbc */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_phi_tbc(g_spinor_field[0], g_spinor_field[1]); xchange_field(g_spinor_field[0]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time to apply Q_tm %e seconds\n", retime-ratime); /* apply gamma5_BdagH4_gamma5 */ gamma5_BdagH4_gamma5(g_spinor_field[2], g_spinor_field[0], g_spinor_field[3]); /* attention: additional factor 2kappa because of CMI format */ /* if(format==1) { for(ix=0; ix<VOLUME; ix++) { _fv_ti_eq_re(&g_spinor_field[2][_GSI(ix)], 2.*g_kappa); } } */ if(Nlong>-1) { if(g_cart_id==0) fprintf(stdout, "# fuzzing propagator with Nlong = %d\n", Nlong); memcpy((void*)g_spinor_field[3], (void*)g_spinor_field[1], 24*VOLUMEPLUSRAND*sizeof(double)); Fuzz_prop(gauge_field_f, g_spinor_field[3], Nlong); } /* add new contractions to disc */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif for(x0=0; x0<T; x0++) { /* loop on time */ for(x1=0; x1<VOL3; x1++) { /* loop on sites in timeslice */ ix = x0*VOL3 + x1; for(mu=0; mu<16; mu++) { /* loop on index of gamma matrix */ _fv_eq_gamma_ti_fv(spinor1, mu, &g_spinor_field[1][_GSI(ix)]); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[2][_GSI(ix)], spinor1); disc[2*( x0*16+mu) ] += w.re; disc[2*( x0*16+mu)+1] += w.im; _fv_eq_gamma_ti_fv(spinor1, 5, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[1][_GSI(ix)], spinor2); disc[2*(16*T + x0*16+mu) ] += w.re; disc[2*(16*T + x0*16+mu)+1] += w.im; if(Nlong>-1) { _fv_eq_gamma_ti_fv(spinor1, mu, &g_spinor_field[3][_GSI(ix)]); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[2][_GSI(ix)], spinor1); disc[2*(32*T + x0*16+mu) ] += w.re; disc[2*(32*T + x0*16+mu)+1] += w.im; _fv_eq_gamma_ti_fv(spinor1, 5, &g_spinor_field[3][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[1][_GSI(ix)], spinor2); disc[2*(48*T + x0*16+mu) ] += w.re; disc[2*(48*T + x0*16+mu)+1] += w.im; } } } } if(g_cart_id==0) fprintf(stdout, "# addimag = %25.16e\n", addimag); if(g_cart_id==0) fprintf(stdout, "# addreal = %25.16e\n", addreal); for(x0=0; x0<T; x0++) { disc[2*( x0*16+4) ] += addreal; disc[2*( x0*16+5)+1] -= addimag; /* if(Nlong>-1) { disc[2*(32*T + x0*16+4) ] += addreal; disc[2*(32*T + x0*16+5)+1] -= addimag; } */ } #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# contractions in %e seconds\n", retime-ratime); /* write current disc to file */ if(g_cart_id==0) { if(sid==g_sourceid) fprintf(ofs1, "#%6d%3d%3d%3d%3d\t%f\t%f\n", Nconf, T, LX, LY, LZ, g_kappa, g_mu); if(sid==g_sourceid) fprintf(ofs2, "#%6d%3d%3d%3d%3d\t%f\t%f\n", Nconf, T, LX, LY, LZ, g_kappa, g_mu); for(x0=0; x0<T; x0++) { for(mu=0; mu<16; mu++) { idx = gindex[mu]; ix = 16*x0 + idx; if(isimag[mu]==0) { fprintf(ofs2, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, x0, sid, gsign[mu]*disc[2* ix ]*v4norm, gsign[mu]*disc[2* ix +1]*v4norm, gsign[mu]*disc[2*(32*T+ix)]*v4norm, gsign[mu]*disc[2*(32*T+ix)+1]*v4norm); } else { fprintf(ofs2, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, x0, sid, gsign[mu]*disc[2*( ix)+1]*v4norm, -gsign[mu]*disc[2* ix ]*v4norm, gsign[mu]*disc[2*(32*T+ix)+1]*v4norm, -gsign[mu]*disc[2*(32*T+ix)]*v4norm); } } } for(x0=0; x0<T; x0++) { for(mu=0; mu<16; mu++) { idx = gindex[mu]; ix = 16*x0 + idx; if(isimag[mu]==0) { fprintf(ofs1, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, x0, sid, gsign[mu]*disc[2*(16*T+ix)+1]*vvnorm, -gsign[mu]*disc[2*(16*T+ix)]*vvnorm, gsign[mu]*disc[2*(48*T+ix)+1]*vvnorm, -gsign[mu]*disc[2*(48*T+ix)]*vvnorm); } else { fprintf(ofs1, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, x0, sid, -gsign[mu]*disc[2*(16*T+ix)]*vvnorm, -gsign[mu]*disc[2*(16*T+ix)+1]*vvnorm, -gsign[mu]*disc[2*(48*T+ix)]*vvnorm, -gsign[mu]*disc[2*(48*T+ix)+1]*vvnorm); } } } #ifdef MPI for(c=1; c<g_nproc; c++) { MPI_Recv(disc, 128*T, MPI_DOUBLE, c, 100+c, g_cart_grid, &status); for(x0=0; x0<T; x0++) { for(mu=0; mu<16; mu++) { idx=gindex[mu]; ix = 16*x0 + idx; if(isimag[mu]==0) { fprintf(ofs2, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, c*T+x0, sid, gsign[mu]*disc[2* ix ]*v4norm, gsign[mu]*disc[2* ix +1]*v4norm, gsign[mu]*disc[2*(32*T+ix)]*v4norm, gsign[mu]*disc[2*(32*T+ix)+1]*v4norm); } else { fprintf(ofs2, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, c*T+x0, sid, gsign[mu]*disc[2*( ix)+1]*v4norm, -gsign[mu]*disc[2* ix ]*v4norm, gsign[mu]*disc[2*(32*T+ix)+1]*v4norm, -gsign[mu]*disc[2*(32*T+ix)]*v4norm); } } } for(x0=0; x0<T; x0++) { for(mu=0; mu<16; mu++) { idx = gindex[mu]; ix = 16*x0 + idx; if(isimag[mu]==0) { fprintf(ofs1, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, c*T+x0, sid, gsign[mu]*disc[2*(16*T+ix)+1]*vvnorm, -gsign[mu]*disc[2*(16*T+ix)]*vvnorm, gsign[mu]*disc[2*(48*T+ix)+1]*vvnorm, -gsign[mu]*disc[2*(48*T+ix)]*vvnorm); } else { fprintf(ofs1, "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, c*T+x0, sid, -gsign[mu]*disc[2*(16*T+ix)]*vvnorm, -gsign[mu]*disc[2*(16*T+ix)+1]*vvnorm, -gsign[mu]*disc[2*(48*T+ix)]*vvnorm, -gsign[mu]*disc[2*(48*T+ix)+1]*vvnorm); } } } } #endif } #ifdef MPI else { for(c=1; c<g_nproc; c++) { if(g_cart_id==c) { MPI_Send(disc, 128*T, MPI_DOUBLE, 0, 100+c, g_cart_grid); } } } #endif } /* of loop on sid */ if(g_cart_id==0) { fclose(ofs1); fclose(ofs2); } if(g_cart_id==0) { fprintf(stdout, "# contributions from HPE:\n"); fprintf(stdout, "(1) X = id\t%25.16e%25.16e\n"\ " \t%25.16e%25.16e\n"\ "(2) X = 5\t%25.16e%25.16e\n"\ " \t%25.16e%25.16e\n", hopexp_coeff[0], hopexp_coeff[1], hopexp_coeff[2], hopexp_coeff[3], hopexp_coeff[4], hopexp_coeff[5], hopexp_coeff[6], hopexp_coeff[7]); } /* free the allocated memory, finalize */ free(g_gauge_field); g_gauge_field=(double*)NULL; for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); g_spinor_field=(double**)NULL; free_geometry(); free(disc); if(Nlong>-1) free(gauge_field_f); #ifdef MPI MPI_Finalize(); #endif return(0); }
int main(int argc, char **argv) { int c, i, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix, iix; int sx0, sx1, sx2, sx3; int sid; double *disc = (double*)NULL; double *disc2 = (double*)NULL; double *work = (double*)NULL; double q[4], fnorm; double cvc_lnuy[8]; double *gauge_trafo=(double*)NULL; double unit_trace[2], D_trace[2]; int verbose = 0; int do_gt = 0; char filename[100]; double ratime, retime; double plaq; double spinor1[24], spinor2[24], U_[18]; complex w, w1, *cp1, *cp2, *cp3; FILE *ofs; fftw_complex *in=(fftw_complex*)NULL; #ifdef MPI fftwnd_mpi_plan plan_p; int *status; #else fftwnd_plan plan_p; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vgf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'g': do_gt = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ set_default_input_values(); if(filename_set==0) strcpy(filename, "cvc.input"); /* read the input file */ read_input(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); #ifdef MPI if((status = (int*)calloc(g_nproc, sizeof(int))) == (int*)NULL) { MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(7); } #endif /* initialize fftw */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; #ifdef MPI plan_p = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_BACKWARD, FFTW_MEASURE); fftwnd_mpi_local_sizes(plan_p, &T, &Tstart, &l_LX_at, &l_LXstart_at, &FFTW_LOC_VOLUME); #else plan_p = fftwnd_create_plan(4, dims, FFTW_BACKWARD, FFTW_MEASURE | FFTW_IN_PLACE); T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; #endif fprintf(stdout, "# [%2d] fftw parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); #ifdef MPI if(T==0) { fprintf(stderr, "[%2d] local T is zero; exit\n", g_cart_id); MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(2); } #endif if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); /* read the gauge field */ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); /* measure the plaquette */ plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value: %25.16e\n", plaq); /* get the source location coordinates */ sx0 = g_source_location / (LX*LY*LZ ); sx1 = ( g_source_location % (LX*LY*LZ) ) / (LY*LZ); sx2 = ( g_source_location % (LY*LZ) ) / LZ; sx3 = ( g_source_location % LZ ); /* read the data for lnuy */ sprintf(filename, "cvc_lnuy_X.%.4d", Nconf); ofs = fopen(filename, "r"); fprintf(stdout, "reading cvc lnuy from file %s\n", filename); for(mu=0; mu<4; mu++) { fscanf(ofs, "%lf%lf", cvc_lnuy+2*mu, cvc_lnuy+2*mu+1); } fclose(ofs); /* allocate memory for the spinor fields */ no_fields = 2; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /**************************************** * allocate memory for the contractions ****************************************/ disc = (double*)calloc(8*VOLUME, sizeof(double)); if( disc == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(3); } for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; disc2 = (double*)calloc(8*VOLUME, sizeof(double)); if( disc2 == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc2\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(3); } for(ix=0; ix<8*VOLUME; ix++) disc2[ix] = 0.; work = (double*)calloc(48*VOLUME, sizeof(double)); if( work == (double*)NULL ) { fprintf(stderr, "could not allocate memory for work\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(3); } /**************************************** * prepare Fourier transformation arrays ****************************************/ in = (fftw_complex*)malloc(FFTW_LOC_VOLUME*sizeof(fftw_complex)); if(in==(fftw_complex*)NULL) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(4); } if(g_resume==1) { /* read current disc from file */ sprintf(filename, ".outcvc_current.%.4d", Nconf); c = read_contraction(disc, &count, filename, 8); #ifdef MPI MPI_Gather(&c, 1, MPI_INT, status, 1, MPI_INT, 0, g_cart_grid); if(g_cart_id==0) { /* check the entries in status */ for(i=0; i<g_nproc; i++) if(status[i]!=0) { status[0] = 1; break; } } MPI_Bcast(status, 1, MPI_INT, 0, g_cart_grid); if(status[0]==1) { for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; count = 0; } #else if(c != 0) { fprintf(stdout, "could not read current disc; start new\n"); for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; count = 0; } #endif if(g_cart_id==0) fprintf(stdout, "starting with count = %d\n", count); } /* of g_resume == 1 */ if(do_gt==1) { /*********************************** * initialize gauge transformation ***********************************/ init_gauge_trafo(&gauge_trafo,1.0); fprintf(stdout, "applying gauge trafo to gauge field\n"); apply_gt_gauge(gauge_trafo); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "plaquette plaq = %25.16e\n", plaq); } unit_trace[0] = 0.; unit_trace[1] = 0.; D_trace[0] = 0.; D_trace[1] = 0.; /**************************************** * start loop on source id.s ****************************************/ for(sid=g_sourceid; sid<=g_sourceid2; sid++) { /**************************************** * read the new propagator ****************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /**************************************** * check: write source before D-appl. ****************************************/ /* if(format==0) { sprintf(filename, "%s.%.4d.%.2d", filename_prefix, Nconf, sid); read_lime_spinor(g_spinor_field[0], filename, 0); } for(ix=0; ix<12*VOLUME; ix++) { fprintf(stdout, "source: %6d%25.16e%25.16e\n", ix, g_spinor_field[0][2*ix], g_spinor_field[0][2*ix+1]); } */ if(format==0) { sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid); /* sprintf(filename, "%s.%.4d.%.2d", filename_prefix, Nconf, sid); */ if(read_lime_spinor(g_spinor_field[1], filename, 0) != 0) break; } else if(format==1) { sprintf(filename, "%s.%.4d.%.5d.inverted", filename_prefix, Nconf, sid); if(read_cmi(g_spinor_field[1], filename) != 0) break; } xchange_field(g_spinor_field[1]); if(do_gt==1) { fprintf(stdout, "applying gt on propagators\n"); for(ix=0; ix<VOLUME; ix++) { _fv_eq_cm_ti_fv(spinor1, gauge_trafo+18*ix, g_spinor_field[1]+_GSI(ix)); _fv_eq_fv(g_spinor_field[1]+_GSI(ix), spinor1); } } #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "time to read prop.: %e seconds\n", retime-ratime); count++; /**************************************** * calculate the source: apply Q_phi_tbc ****************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_phi_tbc(g_spinor_field[0], g_spinor_field[1]); xchange_field(g_spinor_field[0]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "time to calculate source: %e seconds\n", retime-ratime); /**************************************** * check: write source after D-appl. ****************************************/ /* for(ix=0; ix<12*VOLUME; ix++) { fprintf(stdout, "D_source: %6d%25.16e%25.16e\n", ix, g_spinor_field[0][2*ix], g_spinor_field[0][2*ix+1]); } */ /**************************************** * add new contractions to (existing) disc ****************************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif for(mu=0; mu<4; mu++) { /* loop on Lorentz index of the current */ iix = _GWI(mu,0,VOLUME); for(ix=0; ix<VOLUME; ix++) { /* loop on lattice sites */ _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix, mu)], &co_phase_up[mu]); /* first contribution */ _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(ix)], spinor2); disc[iix ] -= 0.5 * w.re; disc[iix+1] -= 0.5 * w.im; /* second contribution */ _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(g_iup[ix][mu])], spinor2); disc2[iix ] -= 0.5 * w.re; disc2[iix+1] -= 0.5 * w.im; iix += 2; } /* of ix */ } /* of mu */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "[%2d] contractions for CVC in %e seconds\n", g_cart_id, retime-ratime); /*************************************************** * check: convergence of trace of unit matrix ***************************************************/ _co_eq_fv_dag_ti_fv(&w, g_spinor_field[0]+_GSI(g_source_location), g_spinor_field[0]+_GSI(g_source_location)); unit_trace[0] += w.re; unit_trace[1] += w.im; fprintf(stdout, "unit_trace: %4d%25.16e%25.16e\n", count, w.re, w.im); _co_eq_fv_dag_ti_fv(&w, g_spinor_field[0]+_GSI(g_source_location), g_spinor_field[0]+_GSI(g_iup[g_source_location][0])); fprintf(stdout, "shift_trace: %4d%25.16e%25.16e\n", count, w.re, w.im); /*************************************************** * check: convergence of trace D_u(source_location, source_location) ***************************************************/ Q_phi_tbc(g_spinor_field[1], g_spinor_field[0]); _co_eq_fv_dag_ti_fv(&w, g_spinor_field[0]+_GSI(g_source_location), g_spinor_field[1]+_GSI(g_source_location)); D_trace[0] += w.re; D_trace[1] += w.im; /* fprintf(stdout, "D_trace: %4d%25.16e%25.16e\n", count, D_trace[0]/(double)count, D_trace[1]/(double)count); */ fprintf(stdout, "D_trace: %4d%25.16e%25.16e\n", count, w.re, w.im); /*************************************************** * save results for count = multiple of Nsave ***************************************************/ if(count%Nsave == 0) { if(g_cart_id == 0) fprintf(stdout, "save results for count = %d\n", count); /* save the result in position space */ /* divide by number of propagators */ for(ix=0; ix<8*VOLUME; ix++) work[ix] = disc[ix] / (double)count; sprintf(filename, "outcvc_Xm.%.4d.%.4d", Nconf, count); write_contraction(work, NULL, filename, 4, 2, 0); for(ix=0; ix<8*VOLUME; ix++) work[ix] = disc2[ix] / (double)count; sprintf(filename, "outcvc_Xp.%.4d.%.4d", Nconf, count); write_contraction(work, NULL, filename, 4, 2, 0); for(ix=0; ix<8*VOLUME; ix++) work[ix] = (disc[ix] + disc2[ix]) / (double)count; sprintf(filename, "outcvc_X.%.4d.%.4d", Nconf, count); write_contraction(work, NULL, filename, 4, 2, 0); #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /**************************************** * Fourier transform data, copy to work ****************************************/ for(mu=0; mu<4; mu++) { memcpy((void*)in, (void*)(work+_GWI(mu,0,VOLUME)), 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif memcpy((void*)(work+_GWI(mu,0,VOLUME)), (void*)in, 2*VOLUME*sizeof(double)); } /* of mu =0 ,..., 3*/ /* fnorm = 1. / ((double)count); */ fprintf(stdout, "fnorm = %e\n", fnorm); for(mu=0; mu<4; mu++) { for(nu=0; nu<4; nu++) { cp1 = (complex*)(work+_GWI(mu,0,VOLUME)); cp2 = (complex*)(cvc_lnuy+2*nu); cp3 = (complex*)(work+_GWI(4+4*mu+nu,0,VOLUME)); for(x0=0; x0<T; x0++) { q[0] = (double)(x0+Tstart) / (double)T_global; for(x1=0; x1<LX; x1++) { q[1] = (double)(x1) / (double)LX; for(x2=0; x2<LY; x2++) { q[2] = (double)(x2) / (double)LY; for(x3=0; x3<LZ; x3++) { q[3] = (double)(x3) / (double)LZ; ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * ( q[mu] - q[nu] - 2.*(sx0*q[0]+sx1*q[1]+sx2*q[2]+sx3*q[3])) ); w.im = sin( M_PI * ( q[mu] - q[nu] - 2.*(sx0*q[0]+sx1*q[1]+sx2*q[2]+sx3*q[3])) ); /* fprintf(stdout, "mu=%3d, nu=%3d, t=%3d, x=%3d, y=%3d, z=%3d, phase= %21.12e + %21.12ei\n", \ mu, nu, x0, x1, x2, x3, w.re, w.im); */ _co_eq_co_ti_co(&w1, cp1, cp2); _co_eq_co_ti_co(cp3, &w1, &w); /* _co_ti_eq_re(cp3, fnorm); */ cp1++; cp3++; } } } } } } /* save the result in momentum space */ sprintf(filename, "outcvc_P.%.4d.%.4d", Nconf, count); write_contraction(work+_GWI(4,0,VOLUME), NULL, filename, 16, 2, 0); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "time to cvc save results: %e seconds\n", retime-ratime); } /* of count % Nsave == 0 */ } /* of loop on sid */ if(g_resume==1) { /* write current disc to file */ sprintf(filename, ".outcvc_current.%.4d", Nconf); write_contraction(disc, &count, filename, 4, 0, 0); } /************************************** * free the allocated memory, finalize **************************************/ free(g_gauge_field); if(do_gt==1) free(gauge_trafo); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); fftw_free(in); free(disc); free(disc2); free(work); #ifdef MPI fftwnd_mpi_destroy_plan(plan_p); free(status); MPI_Finalize(); #else fftwnd_destroy_plan(plan_p); #endif return(0); }
int main(int argc, char **argv) { int c, i, mu, K=16; int count = 0; int filename_set = 0; int x0; int estat; // exit status unsigned long int ix, idx; unsigned long int x1, VOL3, index_min; int sid; double *disc = (double*)NULL, *buffer=NULL, *buffer2=NULL; int verbose = 0; char filename[100]; double ratime, retime; double plaq; double spinor1[24]; double *gauge_field_f=NULL, *gauge_field_timeslice=NULL; double v4norm = 0., vvnorm = 0.; double *psi0 = NULL, *psi1 = NULL, *psi2 = NULL, *psi3 = NULL; complex w; FILE *ofs[4]; double addreal, addimag; /* Initialise all the gamma matrix combinations g5, g1, g2, g3, ig0g5, ig0gi, -1, -g5gi, g0 -g5g0gi */ int gindex[] = {5, 1, 2, 3, 6, 7, 8, 9, 4, 10, 11, 12, 0, 13, 14, 15}; double gsign[] = {-1., 1., 1., 1., -1., 1., 1., 1., 1., 1., 1., 1., 1., 1., -1., 1.}; #ifdef MPI MPI_Status status; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vgf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } // local time stamp g_the_time = time; if(g_cart_id == 0) { fprintf(stdout, "\n# [disc] using global time stamp %s", ctime(&g_the_time)); } /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); #ifdef MPI # if ! ( (defined PARALLELTX) || (defined PARALLELTXY) ) T = T_global / g_nproc; Tstart = g_cart_id * T; # endif #else T = T_global; Tstart = 0; #endif VOL3 = LX*LY*LZ; fprintf(stdout, "# [%2d] parameters:\n"\ "# [%2d] T_global = %3d\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] LX_global = %3d\n"\ "# [%2d] LX = %3d\n"\ "# [%2d] LXstart = %3d\n", g_cart_id, g_cart_id, T_global, g_cart_id, T, g_cart_id, Tstart, g_cart_id, LX_global, g_cart_id, LX, g_cart_id, LXstart); if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); /********************************************** * read the gauge field **********************************************/ // if(N_ape>0 || Nlong>0) { alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "# measured plaquette value: %25.16e\n", plaq); // } else { // g_gauge_field = (double*)NULL; // } if(Nlong > 0) { // N_ape = 1; // alpha_ape = 0.4; if(g_cart_id==0) fprintf(stdout, "# apply fuzzing of gauge field and propagators with parameters:\n"\ "# Nlong = %d\n# N_ape = %d\n# alpha_ape = %f\n", Nlong, N_ape, alpha_ape); alloc_gauge_field(&gauge_field_f, VOLUMEPLUSRAND); #if !( (defined PARALLELTX) || (defined PARALLELTXY) ) gauge_field_timeslice = (double*)calloc(72*VOL3, sizeof(double)); if( gauge_field_timeslice == (double*)NULL ) { fprintf(stderr, "Error, could not allocate mem for gauge_field_timeslice\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(2); } for(x0=0; x0<T; x0++) { memcpy((void*)gauge_field_timeslice, (void*)(g_gauge_field+_GGI(g_ipt[x0][0][0][0],0)), 72*VOL3*sizeof(double)); for(i=0; i<N_ape; i++) { fprintf(stdout, "# [] APE smearing time slice %d step %d\n", x0, i); APE_Smearing_Step_Timeslice(gauge_field_timeslice, alpha_ape); } if(Nlong > 0) { fuzzed_links_Timeslice(gauge_field_f, gauge_field_timeslice, Nlong, x0); } else { memcpy(gauge_field_f+_GGI(g_ipt[x0][0][0][0], 0), gauge_field_timeslice, 72*VOL3*sizeof(double)); } } free(gauge_field_timeslice); #else for(i=0; i<N_ape; i++) { APE_Smearing_Step(g_gauge_field, alpha_ape); xchange_gauge_field_timeslice(g_gauge_field); } if ( Nlong > 0 ) { if(g_cart_id==0) fprintf(stdout, "\n# [hdisc] fuzzing gauge field ...\n"); fuzzed_links2(gauge_field_f, g_gauge_field, Nlong); } else { memcpy(gauge_field_f, g_gauge_field, 72*VOLUMEPLUSRAND*sizeof(double)); } xchange_gauge_field(gauge_field_f); read_lime_gauge_field_doubleprec(filename); xchange_gauge(); #endif /* for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<4; mu++) { for(i=0; i<9; i++) { fprintf(stdout, "%6d%3d%3d%25.16e%25.16e%25.16e%25.16e\n", ix, mu, i, gauge_field_f[_GGI(ix,mu)+2*i], gauge_field_f[_GGI(ix,mu)+2*i+1], g_gauge_field[_GGI(ix,mu)+2*i], g_gauge_field[_GGI(ix,mu)+2*i+1]); }} } */ } // of if Nlong > 0 /* allocate memory for the spinor fields */ no_fields = 8; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUME+RAND); /* allocate memory for the contractions */ /* #ifdef PARALLELTX if(g_xs_id==0) {idx = 4 * 4 * K * T_global * 2;} else {idx = 4 * 4 * K * T * 2;} #else if(g_cart_id==0) {idx = 4 * 4 * K * T_global * 2;} else {idx = 4 * 4 * K* T * 2;} #endif */ disc = (double*)calloc(32*K*T, sizeof(double)); if( disc==(double*)NULL ) { fprintf(stderr, "could not allocate memory for disc\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(3); } buffer = (double*)calloc(32*K*T, sizeof(double)); if( buffer==(double*)NULL ) { fprintf(stderr, "could not allocate memory for buffer\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(4); } buffer2 = (double*)calloc(32*K*T_global, sizeof(double)); if( buffer2==(double*)NULL ) { fprintf(stderr, "could not allocate memory for buffer2\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(5); } if(g_cart_id==0) { sprintf(filename, "hdisc-ss.k0v4.%.4d", Nconf); ofs[0] = fopen(filename, "w"); sprintf(filename, "hdisc-sc.k0v4.%.4d", Nconf); ofs[1] = fopen(filename, "w"); sprintf(filename, "hdisc-cs.k0v4.%.4d", Nconf); ofs[2] = fopen(filename, "w"); sprintf(filename, "hdisc-cc.k0v4.%.4d", Nconf); ofs[3] = fopen(filename, "w"); if(ofs[0]==(FILE*)NULL || ofs[1]==(FILE*)NULL || ofs[2]==(FILE*)NULL || ofs[3]==(FILE*)NULL) { fprintf(stderr, "Error, could not open files for writing.\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(6); } } /***************************************** * HPE coefficients *****************************************/ /* if(format==1) { */ addimag = 2*g_kappa*g_musigma/sqrt(1 + 4*g_kappa*g_kappa*(g_musigma*g_musigma-g_mudelta*g_mudelta)) * LX*LY*LZ*3*4*2.*g_kappa*g_kappa*4; // addreal = (1.+2*g_kappa*g_mudelta)/sqrt(1 + 4*g_kappa*g_kappa*(g_musigma*g_musigma-g_mudelta*g_mudelta)) * // LX*LY*LZ*3*4*2.*g_kappa*g_kappa*4; addreal = (1.- 2*g_kappa*g_mudelta)/sqrt(1 + 4*g_kappa*g_kappa*(g_musigma*g_musigma-g_mudelta*g_mudelta)) * LX*LY*LZ*3*4*2.*g_kappa*g_kappa*4; v4norm = 1. / ( 8. * g_kappa * g_kappa ); vvnorm = 1. / ( 8. * g_kappa * g_kappa ); /* } else { addimag = 2*g_kappa*g_musigma/sqrt(1 + 4*g_kappa*g_kappa*(g_musigma*g_musigma-g_mudelta*g_mudelta)) * LX*LY*LZ*3*4*2.*g_kappa*2; addreal = (1.+2*g_kappa*g_mudelta)/sqrt(1 + 4*g_kappa*g_kappa*(g_musigma*g_musigma-g_mudelta*g_mudelta)) * LX*LY*LZ*3*4*2.*g_kappa*2; v4norm = 1. / ( 4. * g_kappa ); vvnorm = 1. / ( 4. * g_kappa ); } */ if(g_cart_id==0) fprintf(stdout, "# addimag = %25.16e;\t addreal = %25.16e\n"\ "# v4norm = %25.16e;\t vvnorm = %25.16e\n", addimag, addreal, v4norm, vvnorm); /****************************************** * start loop on source id.s ******************************************/ count = -1; for(sid=g_sourceid; sid<=g_sourceid2; sid+=g_sourceid_step) { for(ix=0; ix<32*K*T; ix++) disc[ix] = 0.; for(ix=0; ix<32*K*T; ix++) buffer[ix] = 0.; for(ix=0; ix<32*K*T_global; ix++) buffer2[ix] = 0.; /* read the new propagator */ sprintf(filename, "%s.%.4d.%.5d.hinverted", filename_prefix, Nconf, sid); /* sprintf(filename, "%s.%.4d.%.2d.inverted", filename_prefix, Nconf, sid); */ estat = read_lime_spinor(g_spinor_field[2], filename, 0); if( estat != 0 ) { fprintf(stderr, "[%2d] Error, could not read from file %s at position 0\n", g_cart_id, filename); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(7); } estat = read_lime_spinor(g_spinor_field[3], filename, 1); if( estat != 0 ) { fprintf(stderr, "[%2d] Error, could not read from file %s at position 1\n", g_cart_id, filename); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(7); } count++; xchange_field(g_spinor_field[2]); xchange_field(g_spinor_field[3]); /* calculate the source: apply Q_phi_tbc */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif Q_h_phi(g_spinor_field[0], g_spinor_field[1], g_spinor_field[2], g_spinor_field[3]); xchange_field(g_spinor_field[0]); xchange_field(g_spinor_field[1]); // print the sources /* for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<12; mu++) { fprintf(stdout, "%6d%3d%25.16e%25.16e%25.16e%25.16e\n", ix, mu, g_spinor_field[0][_GSI(ix)+2*mu], g_spinor_field[0][_GSI(ix)+2*mu+1], g_spinor_field[1][_GSI(ix)+2*mu], g_spinor_field[1][_GSI(ix)+2*mu+1]); } } */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "\n# [hdisc] time for applying Q_tm_h: %e seconds\n", retime-ratime); /* apply gamma5_BdagH4_gamma5 */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif gamma5_B_h_dagH4_gamma5(g_spinor_field[4], g_spinor_field[5], g_spinor_field[0], g_spinor_field[1], g_spinor_field[6], g_spinor_field[7]); /* for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<12; mu++) { fprintf(stdout, "%6d%3d%25.16e%25.16e%25.16e%25.16e\n", ix, mu, g_spinor_field[4][_GSI(ix)+2*mu], g_spinor_field[4][_GSI(ix)+2*mu+1], g_spinor_field[5][_GSI(ix)+2*mu], g_spinor_field[5][_GSI(ix)+2*mu+1]); } } */ #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time for applying noise reduction: %e seconds\n", retime-ratime); #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(Nlong>0) { if(g_cart_id==0) fprintf(stdout, "# fuzzing propagator with Nlong = %d\n", Nlong); memcpy((void*)g_spinor_field[6], (void*)g_spinor_field[2], 24*(VOLUME+RAND)*sizeof(double)); /* xchange_field_timeslice(g_spinor_field[6]); */ Fuzz_prop3(gauge_field_f, g_spinor_field[6], g_spinor_field[0], Nlong); xchange_field_timeslice(g_spinor_field[6]); memcpy((void*)g_spinor_field[7], (void*)g_spinor_field[3], 24*(VOLUME+RAND)*sizeof(double)); /* xchange_field_timeslice(g_spinor_field[7]); */ Fuzz_prop3(gauge_field_f, g_spinor_field[7], g_spinor_field[1], Nlong); xchange_field_timeslice(g_spinor_field[7]); } else { for(ix=0;ix<VOLUME;ix++) { _fv_eq_zero(g_spinor_field[6]+_GSI(ix)); } for(ix=0;ix<VOLUME;ix++) { _fv_eq_zero(g_spinor_field[7]+_GSI(ix)); } } /* for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<12; mu++) { fprintf(stdout, "%6d%3d%25.16e%25.16e%25.16e%25.16e\n", ix, mu, g_spinor_field[6][_GSI(ix)+2*mu], g_spinor_field[6][_GSI(ix)+2*mu+1], g_spinor_field[7][_GSI(ix)+2*mu], g_spinor_field[7][_GSI(ix)+2*mu+1]); } } */ // recalculate the sources --- they are changed in Fuzz_prop3 Q_h_phi(g_spinor_field[0], g_spinor_field[1], g_spinor_field[2], g_spinor_field[3]); xchange_field(g_spinor_field[0]); xchange_field(g_spinor_field[1]); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time for fuzzing: %e seconds\n", retime-ratime); /******************************** * add new contractions to disc ********************************/ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif for(c=0; c<4; c++) { if(c==0) { psi0 = g_spinor_field[2]; psi1 = g_spinor_field[4]; psi2 = g_spinor_field[6]; psi3 = g_spinor_field[0]; } if(c==1) { psi0 = g_spinor_field[2]; psi1 = g_spinor_field[5]; psi2 = g_spinor_field[6]; psi3 = g_spinor_field[1]; } if(c==2) { psi0 = g_spinor_field[3]; psi1 = g_spinor_field[4]; psi2 = g_spinor_field[7]; psi3 = g_spinor_field[0]; } if(c==3) { psi0 = g_spinor_field[3]; psi1 = g_spinor_field[5]; psi2 = g_spinor_field[7]; psi3 = g_spinor_field[1]; } /* for(ix=0; ix<VOLUME; ix++) { for(mu=0; mu<12; mu++) { fprintf(stdout, "%6d%3d%16.7e%16.7e%16.7e%16.7e%16.7e%16.7e%16.7e%16.7e\n", ix, mu, psi0[_GSI(ix)+2*mu], psi0[_GSI(ix)+2*mu+1], psi1[_GSI(ix)+2*mu], psi1[_GSI(ix)+2*mu+1], psi2[_GSI(ix)+2*mu], psi2[_GSI(ix)+2*mu+1], psi3[_GSI(ix)+2*mu], psi3[_GSI(ix)+2*mu+1]); } } */ for(x0=0; x0<T; x0++) { for(mu=0; mu<16; mu++) { index_min = x0 * K + mu + c * 4 * K * T; for(x1=0; x1<VOL3; x1++) { ix = x0*VOL3 + x1; idx = _GSI( ix ); _fv_eq_gamma_ti_fv(spinor1, mu, psi0+idx); _co_eq_fv_dag_ti_fv(&w, psi1+idx, spinor1); disc[2*( index_min) ] += w.re; disc[2*( index_min)+1] += w.im; if(Nlong>0) { _fv_eq_gamma_ti_fv(spinor1, mu, psi2+idx); _co_eq_fv_dag_ti_fv(&w, psi1+idx, spinor1); disc[2*( K*T + index_min) ] += w.re; disc[2*( K*T + index_min)+1] += w.im; } _fv_eq_gamma_ti_fv(spinor1, mu, psi0+idx); _co_eq_fv_dag_ti_fv(&w, psi3+idx, spinor1); disc[2*(2*K*T + index_min) ] += w.re; disc[2*(2*K*T + index_min)+1] += w.im; if(Nlong>0) { _fv_eq_gamma_ti_fv(spinor1, mu, psi2+idx); _co_eq_fv_dag_ti_fv(&w, psi3+idx, spinor1); disc[2*(3*K*T + index_min) ] += w.re; disc[2*(3*K*T + index_min)+1] += w.im; } } } } // of loop on x0 for(x0=0; x0<T; x0++) { disc[2*( x0*K+4 + 4*c*K*T) ] += addreal; disc[2*( x0*K+5 + 4*c*K*T)+1] -= addimag; if(Nlong>0) { disc[2*(K*T + x0*K+4 + 4*c*K*T) ] += addreal; disc[2*(K*T + x0*K+5 + 4*c*K*T)+1] -= addimag; } } } // of c=0,...,4 #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "# time for contracting: %e seconds\n", retime-ratime); #ifdef MPI /* collect results to disc */ #if (defined PARALLELTX) || (defined PARALLELTXY) MPI_Allreduce(disc, buffer, 32*K*T, MPI_DOUBLE, MPI_SUM, g_ts_comm); MPI_Allgather(buffer, 32*K*T, MPI_DOUBLE, buffer2, 32*K*T, MPI_DOUBLE, g_xs_comm); # else MPI_Gather(disc, 32*K*T, MPI_DOUBLE, buffer2, 32*K*T, MPI_DOUBLE, 0, g_cart_grid); # endif #else memcpy((void*)buffer2, (void*)disc, 32*K*T_global*sizeof(double)); #endif /* write current disc to file */ if(g_cart_id==0) { for(c=0; c<4; c++) { if(sid==g_sourceid) fprintf(ofs[c], "#%6d%3d%3d%3d%3d\t%f\t%f\t%f\t%f\n", Nconf, T_global, LX_global, LY_global, LZ, g_kappa, g_mu, g_musigma, g_mudelta); for(x0=0; x0<T_global; x0++) { for(mu=0; mu<16; mu++) { idx = gindex[mu]; ix = K*(x0%T) + idx + 16*K*T*(x0/T) + c*4*K*T; fprintf(ofs[c], "%6d%3d%4d%4d%25.16e%25.16e%25.16e%25.16e%25.16e%25.16e%25.16e%25.16e\n", Nconf, mu, x0, sid, gsign[mu]*buffer2[2*( ix)]*v4norm, gsign[mu]*buffer2[2*( ix)+1]*v4norm, gsign[mu]*buffer2[2*( K*T+ix)]*v4norm, gsign[mu]*buffer2[2*( K*T+ix)+1]*v4norm, gsign[mu]*buffer2[2*(2*K*T+ix)]*vvnorm, gsign[mu]*buffer2[2*(2*K*T+ix)+1]*vvnorm, gsign[mu]*buffer2[2*(3*K*T+ix)]*vvnorm, gsign[mu]*buffer2[2*(3*K*T+ix)+1]*vvnorm); } } } } if(g_cart_id==0) fprintf(stdout, "# finished all sid %d\n", sid); } /* of loop on sid */ if(g_cart_id==0) { fclose(ofs[0]); fclose(ofs[1]); fclose(ofs[2]); fclose(ofs[3]); } /* free the allocated memory, finalize */ free(g_gauge_field); if(no_fields>0) { for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); } free_geometry(); free(disc); free(buffer); free(buffer2); if(Nlong>0) free(gauge_field_f); if(g_cart_id == 0) { g_the_time = time(NULL); fprintf(stdout, "\n# [disc] %s# [disc] end of run\n", ctime(&g_the_time)); fprintf(stderr, "\n# [disc] %s# [disc] end of run\n", ctime(&g_the_time)); } #ifdef MPI MPI_Finalize(); #endif return(0); }
int main(int argc, char **argv) { const int n_c = 3; // number of colors int c, i, j, mu, nu, ir, is, ia, imunu; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int source_location, have_source_flag = 0; int x0, x1, x2, x3, ix; int sx0, sx1, sx2, sx3; int isimag[4]; int gperm[5][4], gperm2[4][4]; int check_position_space_WI=0; int num_threads = 1, nthreads=-1, threadid=-1; int exitstatus; int write_ascii=0; int mms = 0, mass_id = -1; int outfile_prefix_set = 0; int source_proc_coords[4], source_proc_id = -1; int ud_single_file = 0; double gperm_sign[5][4], gperm2_sign[4][4]; double *conn = NULL; double *conn2 = NULL; double contact_term[8]; double *work=NULL; int verbose = 0; int do_gt = 0, status; char filename[100], contype[400], outfile_prefix[400]; double ratime, retime; double plaq; double spinor1[24], spinor2[24], U_[18]; double *gauge_trafo=(double*)NULL; double *phi=NULL, *chi=NULL; complex w; double Usourcebuff[72], *Usource[4]; FILE *ofs; #ifdef MPI int *status; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "swah?vgf:t:m:o:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'g': do_gt = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'w': check_position_space_WI = 1; fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] will check Ward identity in position space\n"); break; case 't': num_threads = atoi(optarg); fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] will use %d threads in spacetime loops\n", num_threads); break; case 'a': write_ascii = 1; fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] will write data in ASCII format too\n"); break; case 'm': mms = 1; mass_id = atoi(optarg); fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] will read propagators in MMS format with mass id %d\n", mass_id); break; case 'o': strcpy(outfile_prefix, optarg); fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] will use prefix %s for output filenames\n", outfile_prefix); outfile_prefix_set = 1; break; case 's': ud_single_file = 1; fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] will read up and down propagator from same file\n"); break; case 'h': case '?': default: usage(); break; } } if(g_cart_id==0) { g_the_time = time(NULL); fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] using global time stamp %s", ctime(&g_the_time)); } /********************************* * set number of openmp threads *********************************/ #ifdef OPENMP omp_set_num_threads(num_threads); #endif /* set the default values */ if(filename_set==0) strcpy(filename, "cvc.input"); fprintf(stdout, "# Reading input from file %s\n", filename); read_input_parser(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stderr, "\n[avc_exact2_lowmem_xspace] T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stderr, "\n[avc_exact2_lowmem_xspace] kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); #ifdef MPI if((status = (int*)calloc(g_nproc, sizeof(int))) == (int*)NULL) { MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(7); } #endif dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; #ifndef MPI T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; #endif fprintf(stdout, "# [%2d] parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at); #ifdef MPI if(T==0) { fprintf(stderr, "[%2d] local T is zero; exit\n", g_cart_id); MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(2); } #endif if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); if(!(strcmp(gaugefilename_prefix,"identity")==0)) { /* read the gauge field */ sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); } else { /* initialize unit matrices */ if(g_cart_id==0) fprintf(stdout, "\n# [avc_exact] initializing unit matrices\n"); for(ix=0;ix<VOLUME;ix++) { _cm_eq_id( g_gauge_field + _GGI(ix, 0) ); _cm_eq_id( g_gauge_field + _GGI(ix, 1) ); _cm_eq_id( g_gauge_field + _GGI(ix, 2) ); _cm_eq_id( g_gauge_field + _GGI(ix, 3) ); } } #ifdef MPI xchange_gauge(); #endif /* measure the plaquette */ plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value: %25.16e\n", plaq); /* sprintf(filename, "gauge.%.2d", g_cart_id); ofs = fopen(filename, "w"); for(x0=0;x0<T;x0++) { for(x1=0;x1<LX;x1++) { for(x2=0;x2<LY;x2++) { for(x3=0;x3<LZ;x3++) { ix = g_ipt[x0][x1][x2][x3]; for(mu=0;mu<4;mu++) { for(i=0;i<9;i++) { fprintf(ofs, "%8d%3d%3d%3d%3d%3d%3d%25.16e%25.16e\n", ix, x0+Tstart, x1+LXstart, x2+LYstart, x3, mu, i, g_gauge_field[_GGI(ix,mu)+2*i], g_gauge_field[_GGI(ix,mu)+2*i+1]); } } }}}} fclose(ofs); if(g_cart_id==0) fprintf(stdout, "\nWarning: forced exit\n"); fflush(stdout); fflush(stderr); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 255); MPI_Finalize(); #endif exit(255); */ /* allocate memory for the spinor fields */ no_fields = 2; if(mms) no_fields++; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); if(mms) { work = g_spinor_field[no_fields-1]; } /* allocate memory for the contractions */ conn = (double*)calloc(2 * 16 * VOLUME, sizeof(double)); if( conn==(double*)NULL ) { fprintf(stderr, "could not allocate memory for contr. fields\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 3); MPI_Finalize(); #endif exit(3); } #ifdef OPENMP #pragma omp parallel for #endif for(ix=0; ix<32*VOLUME; ix++) conn[ix] = 0.; conn2 = (double*)calloc(2 * 16 * VOLUME, sizeof(double)); if( conn2 == NULL ) { fprintf(stderr, "could not allocate memory for contr. fields\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 3); MPI_Finalize(); #endif exit(3); } #ifdef OPENMP #pragma omp parallel for #endif for(ix=0; ix<32*VOLUME; ix++) conn2[ix] = 0.; /*********************************************************** * determine source coordinates, find out, if source_location is in this process ***********************************************************/ #if (defined PARALLELTX) || (defined PARALLELTXY) sx0 = g_source_location / (LX_global*LY_global*LZ); sx1 = (g_source_location%(LX_global*LY_global*LZ)) / (LY_global*LZ); sx2 = (g_source_location%(LY_global*LZ)) / LZ; sx3 = (g_source_location%LZ); source_proc_coords[0] = sx0 / T; source_proc_coords[1] = sx1 / LX; source_proc_coords[2] = sx2 / LY; source_proc_coords[3] = 0; MPI_Cart_rank(g_cart_grid, source_proc_coords, &source_proc_id); have_source_flag = (int)(g_cart_id == source_proc_id); if(have_source_flag==1) { fprintf(stdout, "\n# process %2d has source location\n", source_proc_id); fprintf(stdout, "\n# global source coordinates: (%3d,%3d,%3d,%3d)\n", sx0, sx1, sx2, sx3); fprintf(stdout, "\n# source proc coordinates: (%3d,%3d,%3d,%3d)\n", source_proc_coords[0], source_proc_coords[1], source_proc_coords[2], source_proc_coords[3]); } sx0 = sx0 % T; sx1 = sx1 % LX; sx2 = sx2 % LY; sx3 = sx3 % LZ; # else have_source_flag = (int)(g_source_location/(LX*LY*LZ)>=Tstart && g_source_location/(LX*LY*LZ)<(Tstart+T)); if(have_source_flag==1) fprintf(stdout, "process %2d has source location\n", g_cart_id); sx0 = g_source_location/(LX*LY*LZ)-Tstart; sx1 = (g_source_location%(LX*LY*LZ)) / (LY*LZ); sx2 = (g_source_location%(LY*LZ)) / LZ; sx3 = (g_source_location%LZ); #endif if(have_source_flag==1) { fprintf(stdout, "local source coordinates: (%3d,%3d,%3d,%3d)\n", sx0, sx1, sx2, sx3); source_location = g_ipt[sx0][sx1][sx2][sx3]; } #ifdef MPI # if (defined PARALLELTX) || (defined PARALLELTXY) have_source_flag = source_proc_id; MPI_Bcast(Usourcebuff, 72, MPI_DOUBLE, have_source_flag, g_cart_grid); # else MPI_Gather(&have_source_flag, 1, MPI_INT, status, 1, MPI_INT, 0, g_cart_grid); if(g_cart_id==0) { for(mu=0; mu<g_nproc; mu++) fprintf(stdout, "status[%1d]=%d\n", mu,status[mu]); } if(g_cart_id==0) { for(have_source_flag=0; status[have_source_flag]!=1; have_source_flag++); fprintf(stdout, "have_source_flag= %d\n", have_source_flag); } MPI_Bcast(&have_source_flag, 1, MPI_INT, 0, g_cart_grid); # endif fprintf(stdout, "[%2d] have_source_flag = %d\n", g_cart_id, have_source_flag); #else have_source_flag = 0; #endif /* if(g_cart_id==0) fprintf(stdout, "\nWarning: forced exit\n"); fflush(stdout); fflush(stderr); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 255); MPI_Finalize(); #endif exit(255); */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif /*********************************************************** * initialize the Gamma matrices ***********************************************************/ // gamma_5: gperm[4][0] = gamma_permutation[5][ 0] / 6; gperm[4][1] = gamma_permutation[5][ 6] / 6; gperm[4][2] = gamma_permutation[5][12] / 6; gperm[4][3] = gamma_permutation[5][18] / 6; gperm_sign[4][0] = gamma_sign[5][ 0]; gperm_sign[4][1] = gamma_sign[5][ 6]; gperm_sign[4][2] = gamma_sign[5][12]; gperm_sign[4][3] = gamma_sign[5][18]; // gamma_nu gamma_5 for(nu=0;nu<4;nu++) { // permutation gperm[nu][0] = gamma_permutation[6+nu][ 0] / 6; gperm[nu][1] = gamma_permutation[6+nu][ 6] / 6; gperm[nu][2] = gamma_permutation[6+nu][12] / 6; gperm[nu][3] = gamma_permutation[6+nu][18] / 6; // is imaginary ? isimag[nu] = gamma_permutation[6+nu][0] % 2; // (overall) sign gperm_sign[nu][0] = gamma_sign[6+nu][ 0]; gperm_sign[nu][1] = gamma_sign[6+nu][ 6]; gperm_sign[nu][2] = gamma_sign[6+nu][12]; gperm_sign[nu][3] = gamma_sign[6+nu][18]; // write to stdout if(g_cart_id == 0) { fprintf(stdout, "# gamma_%d5 = (%f %d, %f %d, %f %d, %f %d)\n", nu, gperm_sign[nu][0], gperm[nu][0], gperm_sign[nu][1], gperm[nu][1], gperm_sign[nu][2], gperm[nu][2], gperm_sign[nu][3], gperm[nu][3]); } } // gamma_nu for(nu=0;nu<4;nu++) { // permutation gperm2[nu][0] = gamma_permutation[nu][ 0] / 6; gperm2[nu][1] = gamma_permutation[nu][ 6] / 6; gperm2[nu][2] = gamma_permutation[nu][12] / 6; gperm2[nu][3] = gamma_permutation[nu][18] / 6; // (overall) sign gperm2_sign[nu][0] = gamma_sign[nu][ 0]; gperm2_sign[nu][1] = gamma_sign[nu][ 6]; gperm2_sign[nu][2] = gamma_sign[nu][12]; gperm2_sign[nu][3] = gamma_sign[nu][18]; // write to stdout if(g_cart_id == 0) { fprintf(stdout, "# gamma_%d = (%f %d, %f %d, %f %d, %f %d)\n", nu, gperm2_sign[nu][0], gperm2[nu][0], gperm2_sign[nu][1], gperm2[nu][1], gperm2_sign[nu][2], gperm2[nu][2], gperm2_sign[nu][3], gperm2[nu][3]); } } /********************************************************** ********************************************************** ** ** first contribution ** ********************************************************** **********************************************************/ /********************************************** * loop on the Lorentz index nu at source **********************************************/ for(ia=0; ia<n_c; ia++) { for(nu=0; nu<4; nu++) //for(nu=0; nu<4; nu++) { // fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] 1st part, processing nu = %d ...\n", nu); for(ir=0; ir<4; ir++) { // read 1 up-type propagator color components for spinor index ir if(!mms) { get_filename(filename, 0, 3*ir+ia, 1); exitstatus = read_lime_spinor(g_spinor_field[0], filename, 0); if(exitstatus != 0) { fprintf(stderr, "\n# [avc_exact2_lowmem_xspace] Error from read_lime_spinor\n"); exit(111); } xchange_field(g_spinor_field[0]); } else { sprintf(filename, "%s.%.4d.00.%.2d.cgmms.%.2d.inverted", filename_prefix, Nconf, 3*ir+ia, mass_id); exitstatus = read_lime_spinor(work, filename, 0); if(exitstatus != 0) { fprintf(stderr, "\n# [avc_exact2_lowmem_xspace] Error from read_lime_spinor\n"); exit(111); } xchange_field(work); Qf5(g_spinor_field[0], work, -g_mu); xchange_field(g_spinor_field[0]); } // read 1 dn-type propagator color components for spinor index gamma_perm ( ir ) if(!mms) { if(ud_single_file) { get_filename(filename, 0, 3*gperm[nu][ir]+ia, 1); exitstatus = read_lime_spinor(g_spinor_field[1], filename, 1); } else { get_filename(filename, 0, 3*gperm[nu][ir]+ia, -1); exitstatus = read_lime_spinor(g_spinor_field[1], filename, 0); } if(exitstatus != 0) { fprintf(stderr, "\n# [avc_exact2_lowmem_xspace] Error from read_lime_spinor\n"); exit(111); } xchange_field(g_spinor_field[1]); } else { sprintf(filename, "%s.%.4d.%.2d.%.2d.cgmms.%.2d.inverted", filename_prefix, Nconf, 4, 3*gperm[nu][ir]+ia, mass_id); exitstatus = read_lime_spinor(work, filename, 0); if(exitstatus != 0) { fprintf(stderr, "\n# [avc_exact2_lowmem_xspace] Error from read_lime_spinor\n"); exit(111); } xchange_field(work); Qf5(g_spinor_field[1], work, g_mu); xchange_field(g_spinor_field[1]); } phi = g_spinor_field[0]; chi = g_spinor_field[1]; //fprintf(stdout, "\n# [nu5] spin index pair (%d, %d); col index %d\n", ir, gperm[nu][ir], ia); // 1) gamma_nu gamma_5 x U for(mu=0; mu<4; mu++) //for(mu=0; mu<1; mu++) { imunu = 4*mu+nu; #ifdef OPENMP #pragma omp parallel for private(ix, spinor1, spinor2, U_, w) shared(imunu, ia, nu, mu) #endif for(ix=0; ix<VOLUME; ix++) { /* threadid = omp_get_thread_num(); nthreads = omp_get_num_threads(); fprintf(stdout, "[thread%d] number of threads = %d\n", threadid, nthreads); */ _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix,mu)], &co_phase_up[mu]); _fv_eq_cm_ti_fv(spinor1, U_, phi+_GSI(g_iup[ix][mu])); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _fv_eq_gamma_ti_fv(spinor1, 5, spinor2); _co_eq_fv_dag_ti_fv(&w, chi+_GSI(ix), spinor1); if(!isimag[nu]) { conn[_GWI(imunu,ix,VOLUME) ] += gperm_sign[nu][ir] * w.re; conn[_GWI(imunu,ix,VOLUME)+1] += gperm_sign[nu][ir] * w.im; } else { conn[_GWI(imunu,ix,VOLUME) ] += gperm_sign[nu][ir] * w.im; conn[_GWI(imunu,ix,VOLUME)+1] -= gperm_sign[nu][ir] * w.re; } } // of ix #ifdef OPENMP #pragma omp parallel for private(ix, spinor1, spinor2, U_, w) shared(imunu, ia, nu, mu) #endif for(ix=0; ix<VOLUME; ix++) { _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix,mu)], &co_phase_up[mu]); _fv_eq_cm_dag_ti_fv(spinor1, U_, phi+_GSI(ix)); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _fv_eq_gamma_ti_fv(spinor1, 5, spinor2); _co_eq_fv_dag_ti_fv(&w, chi+_GSI(g_iup[ix][mu]), spinor1); if(!isimag[nu]) { conn[_GWI(imunu,ix,VOLUME) ] += gperm_sign[nu][ir] * w.re; conn[_GWI(imunu,ix,VOLUME)+1] += gperm_sign[nu][ir] * w.im; } else { conn[_GWI(imunu,ix,VOLUME) ] += gperm_sign[nu][ir] * w.im; conn[_GWI(imunu,ix,VOLUME)+1] -= gperm_sign[nu][ir] * w.re; } } // of ix // contribution to local-local correlator #ifdef OPENMP #pragma omp parallel for private(ix, spinor1, spinor2, U_, w) shared(imunu, ia, nu, mu) #endif for(ix=0; ix<VOLUME; ix++) { _fv_eq_gamma_ti_fv(spinor2, mu, phi+_GSI(ix) ); _fv_eq_gamma_ti_fv(spinor1, 5, spinor2); _co_eq_fv_dag_ti_fv(&w, chi+_GSI(ix), spinor1); if(!isimag[nu]) { conn2[_GWI(imunu,ix,VOLUME) ] += gperm_sign[nu][ir] * w.re; conn2[_GWI(imunu,ix,VOLUME)+1] += gperm_sign[nu][ir] * w.im; } else { conn2[_GWI(imunu,ix,VOLUME) ] += gperm_sign[nu][ir] * w.im; conn2[_GWI(imunu,ix,VOLUME)+1] -= gperm_sign[nu][ir] * w.re; } } // of ix } // of mu } // of ir } // of nu } // of ia loop on colors // normalisation of contractions #ifdef OPENMP #pragma omp parallel for #endif for(ix=0; ix<32*VOLUME; ix++) conn[ix] *= -0.5; #ifdef OPENMP #pragma omp parallel for #endif for(ix=0; ix<32*VOLUME; ix++) conn2[ix] *= -1.; #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "contractions in %e seconds\n", retime-ratime); // save results #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(outfile_prefix_set) { sprintf(filename, "%s/cvc_lvc_x.%.4d.t%.2dx%.2dy%.2dz%.2d", outfile_prefix, Nconf, sx0, sx1, sx2, sx3); } else { sprintf(filename, "cvc_lvc_x.%.4d.t%.2dx%.2dy%.2dz%.2d", Nconf, sx0, sx1, sx2, sx3); } sprintf(contype, "cvc - lvc in position space, all 16 components"); status = write_lime_contraction(conn, filename, 64, 16, contype, Nconf, 0); if(status != 0) { fprintf(stderr, "[] Error from write_lime_contractions, status was %d\n", status); exit(16); } if(outfile_prefix_set) { sprintf(filename, "%s/lvc_lvc_x.%.4d.t%.2dx%.2dy%.2dz%.2d", outfile_prefix, Nconf, sx0, sx1, sx2, sx3); } else { sprintf(filename, "lvc_lvc_x.%.4d.t%.2dx%.2dy%.2dz%.2d", Nconf, sx0, sx1, sx2, sx3); } sprintf(contype, "lvc - lvc in position space, all 16 components"); status = write_lime_contraction(conn2, filename, 64, 16, contype, Nconf, 0); if(status != 0) { fprintf(stderr, "[] Error from write_lime_contractions, status was %d\n", status); exit(17); } #ifndef MPI if(write_ascii) { if(outfile_prefix_set) { sprintf(filename, "%s/cvc_lvc_x.%.4d.ascii", outfile_prefix, Nconf); } else { sprintf(filename, "cvc_lvc_x.%.4d.ascii", Nconf); } write_contraction(conn, NULL, filename, 16, 2, 0); if(outfile_prefix_set) { sprintf(filename, "%s/lvc_lvc_x.%.4d.ascii", outfile_prefix, Nconf); } else { sprintf(filename, "lvc_lvc_x.%.4d.ascii", Nconf); } write_contraction(conn2, NULL, filename, 16, 2, 0); } #endif #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id==0) fprintf(stdout, "saved position space results in %e seconds\n", retime-ratime); #ifndef MPI // check the Ward identity in position space if(check_position_space_WI) { sprintf(filename, "WI_X.%.4d", Nconf); ofs = fopen(filename,"w"); fprintf(stdout, "\n# [avc_exact2_lowmem_xspace] checking Ward identity in position space ...\n"); for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { fprintf(ofs, "# t=%2d x=%2d y=%2d z=%2d\n", x0, x1, x2, x3); ix=g_ipt[x0][x1][x2][x3]; for(nu=0; nu<4; nu++) { w.re = conn[_GWI(4*0+nu,ix,VOLUME)] + conn[_GWI(4*1+nu,ix,VOLUME)] + conn[_GWI(4*2+nu,ix,VOLUME)] + conn[_GWI(4*3+nu,ix,VOLUME)] - conn[_GWI(4*0+nu,g_idn[ix][0],VOLUME)] - conn[_GWI(4*1+nu,g_idn[ix][1],VOLUME)] - conn[_GWI(4*2+nu,g_idn[ix][2],VOLUME)] - conn[_GWI(4*3+nu,g_idn[ix][3],VOLUME)]; w.im = conn[_GWI(4*0+nu,ix,VOLUME)+1] + conn[_GWI(4*1+nu,ix,VOLUME)+1] + conn[_GWI(4*2+nu,ix,VOLUME)+1] + conn[_GWI(4*3+nu,ix,VOLUME)+1] - conn[_GWI(4*0+nu,g_idn[ix][0],VOLUME)+1] - conn[_GWI(4*1+nu,g_idn[ix][1],VOLUME)+1] - conn[_GWI(4*2+nu,g_idn[ix][2],VOLUME)+1] - conn[_GWI(4*3+nu,g_idn[ix][3],VOLUME)+1]; fprintf(ofs, "\t%3d%25.16e%25.16e\n", nu, w.re, w.im); } }}}} fclose(ofs); } #endif /**************************************** * free the allocated memory, finalize ****************************************/ free(g_gauge_field); for(i=0; i<no_fields; i++) free(g_spinor_field[i]); free(g_spinor_field); free_geometry(); if(conn != NULL) free(conn); if(conn2 != NULL) free(conn2); #ifdef MPI free(status); MPI_Finalize(); #endif if(g_cart_id==0) { g_the_time = time(NULL); fprintf(stdout, "\n# [cvc_lvc_exact2_lowmem_xspace] %s# [cvc_lvc_exact2_lowmem_xspace] end of run\n", ctime(&g_the_time)); fprintf(stderr, "\n# [cvc_lvc_exact2_lowmem_xspace] %s# [cvc_lvc_exact2_lowmem_xspace] end of run\n", ctime(&g_the_time)); } return(0); }
void gamma5_B_h_dagH4_gamma5 (double *xi_c, double *xi_s, double *phi_c, double *phi_s, double *work1, double *work2) { int ix, i; double spinor1[24]; double sign = 1.; // multiply original source (phi) with gamma_5, save in xi for(ix=0; ix<VOLUME; ix++) { _fv_eq_gamma_ti_fv(xi_c + _GSI(ix), 5, phi_c + _GSI(ix) ); } for(ix=0; ix<VOLUME; ix++) { _fv_eq_gamma_ti_fv(xi_s + _GSI(ix), 5, phi_s + _GSI(ix) ); } /************************************************************ * apply B^dagger H four times * - status: source = xi from last step, dest = work * - NOTE: sign = +1 for B^dagger ************************************************************/ // 1st application xchange_field(xi_c); Hopping(work2, xi_c); xchange_field(xi_s); Hopping(work1, xi_s); B_h_phi(xi_c, xi_s, work2, work1, sign); // 2nd application xchange_field(xi_c); Hopping(work1, xi_c); xchange_field(xi_s); Hopping(work2, xi_s); B_h_phi(xi_c, xi_s, work1, work2, sign); // 3rd application xchange_field(xi_c); Hopping(work1, xi_c); xchange_field(xi_s); Hopping(work2, xi_s); B_h_phi(xi_c, xi_s, work1, work2, sign); // 4th application xchange_field(xi_c); Hopping(work1, xi_c); xchange_field(xi_s); Hopping(work2, xi_s); B_h_phi(xi_c, xi_s, work1, work2, sign); /* final step: multiply with gamma_5 and */ for(ix=0; ix<VOLUME; ix++) { _fv_eq_gamma_ti_fv(spinor1, 5, xi_c + _GSI(ix)); _fv_eq_fv(xi_c + _GSI(ix), spinor1); } for(ix=0; ix<VOLUME; ix++) { _fv_eq_gamma_ti_fv(spinor1, 5, xi_s + _GSI(ix)); _fv_eq_fv(xi_s + _GSI(ix), spinor1); } }
int main(int argc, char **argv) { int c, i, mu, nu; int count = 0; int filename_set = 0; int dims[4] = {0,0,0,0}; int l_LX_at, l_LXstart_at; int x0, x1, x2, x3, ix; int sid; double *disc = (double*)NULL; double *work = (double*)NULL; double *disc_diag = (double*)NULL; double phase[4]; int verbose = 0; int do_gt = 0; char filename[100]; double ratime, retime; double plaq; double spinor1[24], spinor2[24], U_[18]; complex w, w1, psi1[4], psi2[4]; FILE *ofs; fftw_complex *in=(fftw_complex*)NULL; #ifdef MPI fftwnd_mpi_plan plan_p, plan_m; int *status; #else fftwnd_plan plan_p, plan_m; #endif #ifdef MPI MPI_Init(&argc, &argv); #endif while ((c = getopt(argc, argv, "h?vgf:")) != -1) { switch (c) { case 'v': verbose = 1; break; case 'g': do_gt = 1; break; case 'f': strcpy(filename, optarg); filename_set=1; break; case 'h': case '?': default: usage(); break; } } /* set the default values */ set_default_input_values(); if(filename_set==0) strcpy(filename, "cvc.input"); /* read the input file */ read_input(filename); /* some checks on the input data */ if((T_global == 0) || (LX==0) || (LY==0) || (LZ==0)) { if(g_proc_id==0) fprintf(stdout, "T and L's must be set\n"); usage(); } if(g_kappa == 0.) { if(g_proc_id==0) fprintf(stdout, "kappa should be > 0.n"); usage(); } /* initialize MPI parameters */ mpi_init(argc, argv); #ifdef MPI if((status = (int*)calloc(g_nproc, sizeof(int))) == (int*)NULL) { MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(7); } #endif /* initialize fftw */ dims[0]=T_global; dims[1]=LX; dims[2]=LY; dims[3]=LZ; #ifdef MPI plan_p = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_BACKWARD, FFTW_MEASURE); plan_m = fftwnd_mpi_create_plan(g_cart_grid, 4, dims, FFTW_FORWARD, FFTW_MEASURE); fftwnd_mpi_local_sizes(plan_p, &T, &Tstart, &l_LX_at, &l_LXstart_at, &FFTW_LOC_VOLUME); #else plan_p = fftwnd_create_plan(4, dims, FFTW_BACKWARD, FFTW_MEASURE | FFTW_IN_PLACE); plan_m = fftwnd_create_plan(4, dims, FFTW_FORWARD, FFTW_MEASURE | FFTW_IN_PLACE); T = T_global; Tstart = 0; l_LX_at = LX; l_LXstart_at = 0; FFTW_LOC_VOLUME = T*LX*LY*LZ; #endif fprintf(stdout, "# [%2d] fftw parameters:\n"\ "# [%2d] T = %3d\n"\ "# [%2d] Tstart = %3d\n"\ "# [%2d] l_LX_at = %3d\n"\ "# [%2d] l_LXstart_at = %3d\n"\ "# [%2d] FFTW_LOC_VOLUME = %3d\n", g_cart_id, g_cart_id, T, g_cart_id, Tstart, g_cart_id, l_LX_at, g_cart_id, l_LXstart_at, g_cart_id, FFTW_LOC_VOLUME); #ifdef MPI if(T==0) { fprintf(stderr, "[%2d] local T is zero; exit\n", g_cart_id); MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); exit(2); } #endif if(init_geometry() != 0) { fprintf(stderr, "ERROR from init_geometry\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(1); } geometry(); /* read the gauge field */ alloc_gauge_field(&g_gauge_field, VOLUMEPLUSRAND); sprintf(filename, "%s.%.4d", gaugefilename_prefix, Nconf); if(g_cart_id==0) fprintf(stdout, "reading gauge field from file %s\n", filename); read_lime_gauge_field_doubleprec(filename); #ifdef MPI xchange_gauge(); #endif /* measure the plaquette */ plaquette(&plaq); if(g_cart_id==0) fprintf(stdout, "measured plaquette value: %25.16e\n", plaq); /* allocate memory for the spinor fields */ no_fields = 2; g_spinor_field = (double**)calloc(no_fields, sizeof(double*)); for(i=0; i<no_fields; i++) alloc_spinor_field(&g_spinor_field[i], VOLUMEPLUSRAND); /* allocate memory for the contractions */ disc = (double*)calloc(8*VOLUME, sizeof(double)); work = (double*)calloc(20*VOLUME, sizeof(double)); if( (disc==(double*)NULL) || (work==(double*)NULL) ) { fprintf(stderr, "could not allocate memory for disc/work\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(3); } for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; if(g_subtract == 1) { /* allocate memory for disc_diag */ disc_diag = (double*)calloc(20*VOLUME, sizeof(double)); if( disc_diag == (double*)NULL ) { fprintf(stderr, "could not allocate memory for disc_diag\n"); #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(8); } for(ix=0; ix<20*VOLUME; ix++) disc_diag[ix] = 0.; } /* prepare Fourier transformation arrays */ in = (fftw_complex*)malloc(FFTW_LOC_VOLUME*sizeof(fftw_complex)); if(in==(fftw_complex*)NULL) { #ifdef MPI MPI_Abort(MPI_COMM_WORLD, 1); MPI_Finalize(); #endif exit(4); } if(g_resume==1) { /* read current disc from file */ sprintf(filename, ".outcvc_current.%.4d", Nconf); c = read_contraction(disc, &count, filename, 4); if( (g_subtract==1) && (c==0) ) { sprintf(filename, ".outcvc_diag_current.%.4d", Nconf); c = read_contraction(disc_diag, (int*)NULL, filename, 10); } #ifdef MPI MPI_Gather(&c, 1, MPI_INT, status, 1, MPI_INT, 0, g_cart_grid); if(g_cart_id==0) { /* check the entries in status */ for(i=0; i<g_nproc; i++) if(status[i]!=0) { status[0] = 1; break; } } MPI_Bcast(status, 1, MPI_INT, 0, g_cart_grid); if(status[0]==1) { for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; count = 0; } #else if(c != 0) { fprintf(stdout, "could not read current disc; start new\n"); for(ix=0; ix<8*VOLUME; ix++) disc[ix] = 0.; if(g_subtract==1) for(ix=0; ix<20*VOLUME; ix++) disc_diag[ix] = 0.; count = 0; } #endif if(g_cart_id==0) fprintf(stdout, "starting with count = %d\n", count); } /* of g_resume == 1 */ /* start loop on source id.s */ for(sid=g_sourceid; sid<=g_sourceid2; sid++) { /* read the new propagator */ /* sprintf(filename, "%s.%.4d.%.2d", filename_prefix, Nconf, sid); */ sprintf(filename, "source.%.4d.%.2d.inverted", Nconf, sid); if(format==0) { if(read_lime_spinor(g_spinor_field[1], filename, 0) != 0) break; } else if(format==1) { if(read_cmi(g_spinor_field[1], filename) != 0) break; } count++; xchange_field(g_spinor_field[1]); /* calculate the source: apply Q_phi_tbc */ Q_phi_tbc(g_spinor_field[0], g_spinor_field[1]); xchange_field(g_spinor_field[0]); /* sprintf(filename, "%s.source.%.2d", filename, g_cart_id); ofs = fopen(filename, "w"); printf_spinor_field(g_spinor_field[0], ofs); fclose(ofs); */ /* add new contractions to (existing) disc */ #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif for(ix=0; ix<VOLUME; ix++) { /* loop on lattice sites */ for(mu=0; mu<4; mu++) { /* loop on Lorentz index of the current */ _cm_eq_cm_ti_co(U_, &g_gauge_field[_GGI(ix, mu)], &co_phase_up[mu]); /* first contribution */ _fv_eq_cm_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(g_iup[ix][mu])]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_mi_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(ix)], spinor2); disc[_GJI(ix, mu) ] -= 0.25 * w.re; disc[_GJI(ix, mu)+1] -= 0.25 * w.im; if(g_subtract==1) { work[_GWI(mu,ix,VOLUME) ] = -0.25 * w.re; work[_GWI(mu,ix,VOLUME)+1] = -0.25 * w.im; } /* second contribution */ _fv_eq_cm_dag_ti_fv(spinor1, U_, &g_spinor_field[1][_GSI(ix)]); _fv_eq_gamma_ti_fv(spinor2, mu, spinor1); _fv_pl_eq_fv(spinor2, spinor1); _co_eq_fv_dag_ti_fv(&w, &g_spinor_field[0][_GSI(g_iup[ix][mu])], spinor2); disc[_GJI(ix, mu) ] -= 0.25 * w.re; disc[_GJI(ix, mu)+1] -= 0.25 * w.im; if(g_subtract==1) { work[_GWI(mu,ix,VOLUME) ] -= 0.25 * w.re; work[_GWI(mu,ix,VOLUME)+1] -= 0.25 * w.im; } } } #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "[%2d] contractions in %e seconds\n", g_cart_id, retime-ratime); if(g_subtract==1) { /* add current contribution to disc_diag */ for(mu=0; mu<4; mu++) { for(i=0; i<4; i++) phase[i] = (double)(i==mu); memcpy((void*)in, (void*)&work[_GWI(mu,0,VOLUME)], 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); w.im = -sin( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); _co_eq_co_ti_co(&w1, &in[ix], &w); work[_GWI(4+mu,ix,VOLUME) ] = w1.re; work[_GWI(4+mu,ix,VOLUME)+1] = w1.im; } } } } memcpy((void*)in, (void*)&work[_GWI(mu,0,VOLUME)], 2*VOLUME*sizeof(double)); #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); w.im = sin( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); _co_eq_co_ti_co(&w1, &in[ix], &w); work[_GWI(mu,ix,VOLUME) ] = w1.re; work[_GWI(mu,ix,VOLUME)+1] = w1.im; } } } } } /* of mu */ for(ix=0; ix<VOLUME; ix++) { i=-1; for(mu=0; mu<4; mu++) { for(nu=mu; nu<4; nu++) { i++; _co_eq_co_ti_co(&w, (complex*)&work[_GWI(mu,ix,VOLUME)], (complex*)&work[_GWI(4+nu,ix,VOLUME)]); disc_diag[_GWI(ix,i,10) ] += w.re; disc_diag[_GWI(ix,i,10)+1] += w.im; } } } } /* of g_subtract == 1 */ /* save results for count = multiple of Nsave */ if(count%Nsave == 0) { #ifdef MPI ratime = MPI_Wtime(); #else ratime = (double)clock() / CLOCKS_PER_SEC; #endif if(g_cart_id == 0) fprintf(stdout, "save results for count = %d\n", count); /* save the result in position space */ sprintf(filename, "outcvc_X.%.4d.%.4d", Nconf, count); write_contraction(disc, NULL, filename, 4, 1, 0); /* Fourier transform data, copy to work */ for(mu=0; mu<4; mu++) { for(i=0; i<4; i++) phase[i] = (double)(i==mu); for(ix=0; ix<VOLUME; ix++) { in[ix].re = disc[_GJI(ix,mu) ]; in[ix].im = disc[_GJI(ix,mu)+1]; } #ifdef MPI fftwnd_mpi(plan_m, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_m, in, NULL); #endif for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); w.im = -sin( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); _co_eq_co_ti_co(&w1, &in[ix], &w); work[_GWI(ix,4+mu,8) ] = w1.re / (double)count; work[_GWI(ix,4+mu,8)+1] = w1.im / (double)count; } } } } for(ix=0; ix<VOLUME; ix++) { in[ix].re = disc[_GJI(ix, mu) ]; in[ix].im = disc[_GJI(ix, mu)+1]; } #ifdef MPI fftwnd_mpi(plan_p, 1, in, NULL, FFTW_NORMAL_ORDER); #else fftwnd_one(plan_p, in, NULL); #endif for(x0=0; x0<T; x0++) { for(x1=0; x1<LX; x1++) { for(x2=0; x2<LY; x2++) { for(x3=0; x3<LZ; x3++) { ix = g_ipt[x0][x1][x2][x3]; w.re = cos( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); w.im = sin( M_PI * (phase[0]*(double)(Tstart+x0)/(double)T_global + phase[1]*(double)x1/(double)LX + phase[2]*(double)x2/(double)LY + phase[3]*(double)x3/(double)LZ) ); _co_eq_co_ti_co(&w1, &in[ix], &w); work[_GWI(ix,mu,8) ] = w1.re / (double)count; work[_GWI(ix,mu,8)+1] = w1.im / (double)count; } } } } } /* of mu =0 ,..., 3*/ /* save the result in momentum space */ sprintf(filename, "outcvc_P.%.4d.%.4d", Nconf, count); write_contraction(work, NULL, filename, 8, 1, 0); /* calculate the correlations 00, 01, 02, 03, 11, 12, ..., 23, 33 */ for(ix=VOLUME-1; ix>=0; ix--) { /* copy current data to auxilliary vector */ memcpy((void*)psi1, (void*)&work[_GWI(ix,0,8)], 8*sizeof(double)); memcpy((void*)psi2, (void*)&work[_GWI(ix,4,8)], 8*sizeof(double)); i = -1; for(mu=0; mu<4; mu++) { for(nu=mu; nu<4; nu++) { i++; _co_eq_co_ti_co(&w,&psi1[mu],&psi2[nu]); if(g_subtract !=1 ) { work[_GWI(ix,i,10) ] = w.re / (double)(T_global*LX*LY*LZ); work[_GWI(ix,i,10)+1] = w.im / (double)(T_global*LX*LY*LZ); } else { work[_GWI(ix,i,10) ] = ( w.re - disc_diag[_GWI(ix,i,10) ]/(double)(count*count) ) / (double)(T_global*LX*LY*LZ); work[_GWI(ix,i,10)+1] = ( w.im - disc_diag[_GWI(ix,i,10)+1]/(double)(count*count) ) / (double)(T_global*LX*LY*LZ); } } } } /* save current results to file */ sprintf(filename, "outcvc_final.%.4d.%.4d", Nconf, count); write_contraction(work, (int*)NULL, filename, 10, 1, 0); #ifdef MPI retime = MPI_Wtime(); #else retime = (double)clock() / CLOCKS_PER_SEC; #endif fprintf(stdout, "[%2d] time to save results: %e seconds\n", g_cart_id, retime-ratime); } /* of count % Nsave == 0 */ } /* of loop on sid */ /* write current disc to file */ sprintf(filename, ".outcvc_current.%.4d", Nconf); write_contraction(disc, &count, filename, 4, 0, 0); if(g_subtract == 1) { /* write current disc_diag to file */ sprintf(filename, ".outcvc_diag_current.%.4d", Nconf); write_contraction(disc_diag, (int*)NULL, filename, 10, 0, 0); } /* free the allocated memory, finalize */ free(g_gauge_field); g_gauge_field=(double*)NULL; for(i=0; i<no_fields; i++) { free(g_spinor_field[i]); g_spinor_field[i] = (double*)NULL; } free(g_spinor_field); g_spinor_field=(double**)NULL; free_geometry(); fftw_free(in); free(disc); free(work); if(g_subtract==1) free(disc_diag); #ifdef MPI fftwnd_mpi_destroy_plan(plan_p); fftwnd_mpi_destroy_plan(plan_m); free(status); MPI_Finalize(); #else fftwnd_destroy_plan(plan_p); fftwnd_destroy_plan(plan_m); #endif return(0); }