int main()
{
long N, i;
scanf("%li\n", &N);
char **strarray = (char **)malloc(N * sizeof(char *));
if (strarray == NULL) return 1;
for (i = 0 ; i < N ; i++)
{
//sa fim siguri in cazuri de linii lungi
char *temp_pointer = (char *)malloc(16000 * sizeof(char));
if (temp_pointer == NULL) return 1;
fgets(temp_pointer, 14000, stdin);
if (strcmp(temp_pointer, "\n") == 0)
{
//daca e doar o linie goala
temp_pointer[0]='\0'; //scap de newline
}
else
{
//scapam de trailing newline de la fgets
//intr-un mod mai scurt si concis
strtok(temp_pointer, "\n");
}
strarray[i] = realloc(temp_pointer, strlen(temp_pointer) * sizeof(char) + 1);
if (strarray[i] == NULL) return 1;
}
int nr_op, op, j, rezultat;
scanf("%d", &nr_op);
for (j=0 ; j < nr_op ; j++)
{
scanf("%d", &op);
switch(op)
{
case 1:
rezultat = op_1(strarray, N);
break;
case 2:
rezultat = op_2(strarray, N);
break;
case 3:
rezultat = op_3(strarray, N);
break;
default:
return 1;
}
if (rezultat) return 1; //nu s-a alocat memoria cum trebuie
}
return 0;
}
void interpret(uint16_t opcode){
int firstnibble = (opcode & 0xF000) >> 12;
switch(firstnibble){
case 0:
op_0(opcode);
break;
case 1:
op_1(opcode);
break;
case 2:
op_2(opcode);
break;
case 3:
op_3(opcode);
break;
case 4:
op_4(opcode);
break;
case 5:
op_5(opcode);
break;
case 6:
op_6(opcode);
break;
case 7:
op_7(opcode);
break;
case 8:
op_8(opcode);
break;
case 9:
op_9(opcode);
break;
case 0xA:
op_A(opcode);
break;
case 0xB:
op_B(opcode);
break;
case 0xC:
op_C(opcode);
break;
case 0xD:
op_D(opcode);
break;
case 0xE:
op_E(opcode);
break;
case 0xF:
op_F(opcode);
break;
}
}
int main (int ac, char* av[]) {
// ***************************************************************************
// ***************************************************************************
// initialization ************************************************************
// ***************************************************************************
// ***************************************************************************
// initialization of eigen OMP paralization
Eigen::initParallel();
// set numer of threads used by eigen
// first line sets number of threads directly
// second line lets OMP decide on the number of threads,
// e. g. via OMP_NUM_THREADS
//Eigen::setNbThreads(4);
Eigen::setNbThreads(0);
//check the number of threads used
const int nthreads = Eigen::nbThreads();
std::cout << "contraction code for stochastic dilution" << std::endl;
std::cout << "using " << nthreads << " threads for eigen\n" << std::endl;
// reading in global parameters from input file
GlobalData* global_data = GlobalData::Instance();
global_data->read_parameters(ac, av);
// reading in of data
ReadWrite* rewr = new ReadWrite;
// everything for operator handling
BasicOperator* basic = new BasicOperator();
// global variables from input file needed in main function
const int Lt = global_data->get_Lt();
const int end_config = global_data->get_end_config();
const int delta_config = global_data->get_delta_config();
const int start_config = global_data->get_start_config();
const int number_of_eigen_vec = global_data->get_number_of_eigen_vec();
const int number_of_max_mom = global_data->get_number_of_max_mom();
const int max_mom_squared = number_of_max_mom * number_of_max_mom;
const int number_of_momenta = global_data->get_number_of_momenta();
const std::vector<int> mom_squared = global_data->get_momentum_squared();
const std::vector<quark> quarks = global_data->get_quarks();
const int number_of_rnd_vec = quarks[0].number_of_rnd_vec;
const int dirac_min = global_data->get_dirac_min();
const int dirac_max = global_data->get_dirac_max();
const int number_of_dirac = dirac_max - dirac_min + 1;
const int displ_min = global_data->get_displ_min();
const int displ_max = global_data->get_displ_max();
const int number_of_displ = displ_max - displ_min + 1;
const int p_min = 0; //number_of_momenta/2;
const int p_max = number_of_momenta;
// TODO decide on path
std::string outpath = global_data->get_output_path() + "/";
// other variables
clock_t time;
const std::complex<double> I(0.0, 1.0);
char outfile[400];
FILE *fp = NULL;
// ***************************************************************************
// ***************************************************************************
// memory allocation *********************************************************
// ***************************************************************************
// ***************************************************************************
// abbreviations for clearer memory allocation. Wont be used in loops and
// when building the contractions
// CJ: but it is a little bit ugly...
const size_t nmom = number_of_momenta;
const size_t nrnd = number_of_rnd_vec;
const size_t ndir = number_of_dirac;
const size_t ndis = number_of_displ;
// memory for the correlation function
array_cd_d7 C2_mes(boost::extents[nmom][nmom][ndir][ndir][ndis][ndis][Lt]);
//TODO: dont need the memory for p_u^2 > p_d^2
array_cd_d10 Corr(boost::extents[nmom][nmom][ndir][ndir][ndis][ndis][Lt][Lt][nrnd][nrnd]);
int norm = 0;
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd3 = rnd1 + 1; rnd3 < number_of_rnd_vec; ++rnd3){
for(int rnd2 = 0; rnd2 < number_of_rnd_vec; ++rnd2){
if((rnd2 != rnd1) && (rnd2 != rnd3)){
for(int rnd4 = rnd2 + 1; rnd4 < number_of_rnd_vec; ++rnd4){
if((rnd4 != rnd1) && (rnd4 != rnd3)){
norm++;
//std::cout << "\n\nnorm: " << norm << rnd1 << rnd3 << rnd2 << rnd4 << std::endl;
}
}
}
}
}
}
std::cout << "\n\tNumber of contraction combinations: " << norm << std::endl;
// const double norm1 = Lt * norm;
// Memory for propagation matrices (is that a word?) from t_source to t_sink
// (op_1) and vice versa (op_2)
// additional t_source to t_sink (op_3) and t_sink to t_source (op_4) for
// 4-point functions
// 1, 3 -> u-quarks; 2, 4 -> d-quarks; 5, 6 -> u quarks for neutral particle
array_Xcd_d2_eigen op_1(boost::extents[nrnd][nrnd]);
array_Xcd_d2_eigen op_3(boost::extents[nrnd][nrnd]);
vec_Xcd_eigen op_2(number_of_rnd_vec);
vec_Xcd_eigen op_4(number_of_rnd_vec);
vec_Xcd_eigen op_5(number_of_rnd_vec);
vec_Xcd_eigen op_6(number_of_rnd_vec);
for(int rnd_i = 0; rnd_i < number_of_rnd_vec; ++rnd_i){
for(int rnd_j = 0; rnd_j < number_of_rnd_vec; ++rnd_j){
op_1[rnd_i][rnd_j] = Eigen::MatrixXcd(4 * number_of_eigen_vec,
4 * quarks[0].number_of_dilution_E);
}
op_2[rnd_i] = Eigen::MatrixXcd(4 * quarks[0].number_of_dilution_E,
4 * number_of_eigen_vec);
}
// ***************************************************************************
// ***************************************************************************
// Loop over all configurations **********************************************
// ***************************************************************************
// ***************************************************************************
for(int config_i = start_config; config_i <= end_config; config_i +=
delta_config){
std::cout << "\nprocessing configuration: " << config_i << "\n\n";
rewr->read_perambulators_from_file(config_i);
rewr->read_rnd_vectors_from_file(config_i);
// rewr->read_eigenvectors_from_file(config_i);
rewr->read_lime_gauge_field_doubleprec_timeslices(config_i);
rewr->build_source_matrix(config_i);
// *************************************************************************
// TWO PT CONTRACTION 1 ****************************************************
// *************************************************************************
// setting the correlation function to zero
std::cout << "\n\tcomputing the connected contribution of pi_+/-:\n";
time = clock();
// setting the correlation function to zero
for(int p1 = 0; p1 < number_of_momenta; ++p1)
for(int p2 = 0; p2 < number_of_momenta; ++p2)
for(int dirac1 = 0; dirac1 < number_of_dirac; ++dirac1)
for(int dirac2 = 0; dirac2 < number_of_dirac; ++dirac2)
for(int displ1 = 0; displ1 < number_of_displ; ++displ1)
for(int displ2 = 0; displ2 < number_of_displ; ++displ2)
for(int t1 = 0; t1 < Lt; ++t1)
for(int t1 = 0; t1 < Lt; ++t1)
C2_mes[p1][p2][dirac1][dirac2][displ1][displ2][t1] = std::complex<double>(0.0, 0.0);
for(int p1 = 0; p1 < number_of_momenta; ++p1)
for(int p2 = 0; p2 < number_of_momenta; ++p2)
for(int dirac1 = 0; dirac1 < number_of_dirac; ++dirac1)
for(int dirac2 = 0; dirac2 < number_of_dirac; ++dirac2)
for(int displ1 = 0; displ1 < number_of_displ; ++displ1)
for(int displ2 = 0; displ2 < number_of_displ; ++displ2)
for(int t1 = 0; t1 < Lt; ++t1)
for(int t2 = 0; t2 < Lt; ++t2)
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; rnd1++)
for(int rnd2 = 0; rnd2 < number_of_rnd_vec; rnd2++)
Corr[p1][p2][dirac1][dirac2][displ1][displ2][t1][t2][rnd1][rnd2] =
std::complex<double>(0.0, 0.0);
#if 1 // PI^+/-
// initializing of Corr: calculate all two-operator traces of the form tr(u \Gamma \bar{d})
// build all combinations of momenta, dirac_structures and displacements as specified in
// infile
for(int displ_u = 0; displ_u < number_of_displ; displ_u++){
for(int displ_d = 0; displ_d < number_of_displ; displ_d++){
for(int t_source = 0; t_source < Lt; ++t_source){
for(int t_sink = 0; t_sink < Lt; ++t_sink){
for(int p = p_min; p < p_max; ++p) {
// initialize contraction[rnd_i] = perambulator * basicoperator
// = D_u^-1
// choose 'i' for interlace or 'b' for block time dilution scheme
// TODO: get that from input file
// choose 'c' for charged or 'u' for uncharged particles
basic->init_operator_u(0, t_source, t_sink, rewr, 'b', p, displ_min + displ_u);
basic->init_operator_d(0, t_source, t_sink, rewr, 'b', p, displ_min + displ_d);
}
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int p_u = p_min; p_u < p_max; ++p_u) {
// code for pi+-
// "multiply contraction[rnd_i] with gamma structure"
// contraction[rnd_i] are the columns of D_u^-1 which get
// reordered by gamma multiplication. No actual multiplication
// is carried out
basic->get_operator_charged(op_1, 0, t_sink, rewr, dirac_min + dirac_u, p_u);
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
// same as get_operator but with gamma_5 trick. D_u^-1 is
// daggered and multipied with gamma_5 from left and right
// the momentum is changed to reflect the switched sign in
// the momentum exponential for pi_+-
basic->get_operator_g5(op_2, 0, dirac_min + dirac_d, p_d);
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd2 = rnd1 + 1; rnd2 < number_of_rnd_vec; ++rnd2){
// build all 2pt traces leading to C2_mes
// Corr = tr(D_d^-1(t_sink) Gamma
// D_u^-1(t_source) Gamma)
Corr[p_u][p_d][dirac_u][dirac_d][displ_u][displ_d]
[t_source][t_sink][rnd1][rnd2] =
(op_2[rnd2] * op_1[rnd1][rnd2]).trace();
// std::cout << "p" << p_u << p_d << "dirac" << dirac_u << dirac_d << "\nCorr "
// << Corr[p_u][p_d][dirac_u][dirac_d][displ_u][displ_d]
// [t_source][t_sink][rnd1][rnd2] << std::endl;
}
}
}
}
}
}
}
}
}
}
}
// build 2pt-function C2_mes for pi^+ from Corr. Equivalent two just summing
// up traces with same time difference between source and sink (all to all)
// for every dirac structure, momentum, displacement
// build 2pt-function C2_mes for pi^+ from Corr. Equivalent two just summing
// up traces with same time difference between source and sink (all to all)
// for every dirac structure, momentum, displacement
for(int t_source = 0; t_source < Lt; ++t_source){
for(int t_sink = 0; t_sink < Lt; ++t_sink){
for(int p_u = p_min; p_u < p_max; ++p_u) {
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int displ_u = 0; displ_u < number_of_displ; displ_u++){
for(int displ_d = 0; displ_d < number_of_displ; displ_d++){
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd2 = rnd1 + 1; rnd2 < number_of_rnd_vec; ++rnd2){
// building Correlation function
// C2 = tr(D_d^-1 Gamma D_u^-1 Gamma)
// TODO: find signflip of imaginary part
// TODO: is C2_mes[dirac][p] better?
C2_mes[p_u][p_d][dirac_u][dirac_d][displ_u][displ_d]
[abs((t_sink - t_source - Lt) % Lt)] +=
Corr[p_u][number_of_momenta - p_d - 1]
[dirac_u][dirac_d][displ_u][displ_d]
[t_source][t_sink][rnd1][rnd2];
}
}
}
}
}
}
}
}
}
}
}
// normalization of correlation function
double norm3 = Lt * number_of_rnd_vec * (number_of_rnd_vec - 1) * 0.5;
for(int p_u = p_min; p_u < p_max; ++p_u) {
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int displ_u = 0; displ_u < number_of_displ; ++displ_u){
for(int displ_d = 0; displ_d < number_of_displ; ++displ_d){
for(int t = 0; t < Lt; ++t){
C2_mes[p_u][p_d][dirac_u][dirac_d][displ_u][displ_d][t] /= norm3;
}
}
}
}
}
}
}
}
#endif
// output to binary file
// to build a GEVP, the correlators are written into a seperate folder
// for every dirac structure, momentum, displacement (entry of the GEVP
// matrix). In the folders a file is created for every configuration which
// contains all momentum combinations with same momentum squared
// The folders are created when running create_runs.sh. If they dont exist,
// a segmentation fault will occur
// TODO: implement check for existence of folders
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p = 0; p <= max_mom_squared; p++){
for(int displ_u = 0; displ_u < number_of_displ; ++displ_u){
for(int displ_d = 0; displ_d < number_of_displ; ++displ_d){
sprintf(outfile,
"%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d_unsuppressed/"
"C2_pi+-_conf%04d.dat",
outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d, p, p,
displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = p_min; p_u < p_max; ++p_u){
if(rewr.mom_squared[p_u] == p){
fwrite((double*) &(C2_mes[p_u][p_u][dirac_u][dirac_d]
[displ_u][displ_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
fclose(fp);
}
}
}
}
}
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p1 = 0; p1 <= max_mom_squared; p1++){
for(int p2 = p1; p2 <= max_mom_squared; p2++){
for(int displ_u = 0; displ_u < number_of_displ; ++displ_u){
for(int displ_d = 0; displ_d < number_of_displ; ++displ_d){
printf("Writing to file: ");
// sprintf(outfile,
// "%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d/"
// "C2_pi+-_conf%04d.dat",
// outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d,
// p1, p2, displ_min + displ_u, displ_min + displ_d, config_i);
sprintf(outfile, "%s/C2_pi+-_conf%04d.dat", outpath.c_str(), config_i);
printf("%s\n", outfile);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = p_min; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p1){
for(int p_d = p_min; p_d < p_max; ++p_d){
if(mom_squared[p_d] == p2){
fwrite((double*) &(C2_mes[p_u][p_d][dirac_u][dirac_d][displ_u][displ_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
}
}
fclose(fp);
}
}
}
}
}
}
#if 0 // (old?) output routine and output to terminal
sprintf(outfile,
"%s/dirac_%02d_%02d_p_0_%01d_displ_%01d_%01d/C2_pi+-_conf%04d.dat",
outpath.c_str(), dirac_min, dirac_max, 0,
displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac)
fwrite((double*) C2_mes[number_of_momenta/2]
[number_of_momenta/2][dirac], sizeof(double), 2 * Lt, fp);
fclose(fp);
for(int rnd_i = 0; rnd_i < number_of_rnd_vec; ++rnd_i) {
sprintf(outfile,
"%s/dirac_%02d_%02d_p_0_%01d_displ_%01d_%01d/C2_dis_u_rnd%02d_conf%04d.dat",
outpath.c_str(), dirac_min, dirac_max, number_of_max_mom, displ_min,
displ_max, rnd_i, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac)
for(int p = 0; p < number_of_momenta; ++p)
fwrite((double*) C2_dis[p][dirac][rnd_i], sizeof(double), 2 * Lt, fp);
fclose(fp);
}
// output to terminal
// printf("\n");
// for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac){
// printf("\tdirac = %02d\n", dirac);
// for(int p = 0; p <= max_mom_squared; p++){
// printf("\tmomentum_u = %02d\n", p);
// printf("\tmomentum_d = %02d\n", p);
// for(int p_u = p_min; p_u < p_max; ++p_u){
// if((mom_squared[p_u] == p)){
// //printf(
// // "\t t\tRe(C2_con)\tIm(C2_con)\n\t----------------------------------\n");
//// for(int t1 = 0; t1 < Lt; ++t1){
//// printf("\t%02d\t%.5e\t%.5e\n", t1, real(C2_mes[p_u][p_u][dirac][t1]),
//// imag(C2_mes[p_u][p_u][dirac][t1]));
//// }
// printf("\n");
// printf("p_u = %02d\n", p_u);
// }
// }
// }
//
// for(int p = 1; p <= max_mom_squared; p++){
// printf("\tmomentum_u = %02d\n", 0);
// printf("\tmomentum_d = %02d\n", p);
// for(int p_u = p_min; p_u < p_max; ++p_u){
// if((mom_squared[p_u] == p)){
// //printf(
// // "\t t\tRe(C2_con)\tIm(C2_con)\n\t----------------------------------\n");
//// for(int t1 = 0; t1 < Lt; ++t1){
//// printf("\t%02d\t%.5e\t%.5e\n", t1, real(C2_mes[p_u][p_u][dirac][t1]),
//// imag(C2_mes[p_u][p_u][dirac][t1]));
//// }
// printf("\n");
// printf("p_u = %02d\n", p_u);
// }
// }
// }
//
// }
#endif // (old?) output routine and output to terminal
time = clock() - time;
std::cout << "\t\tSUCCESS - " << std::fixed << std::setprecision(1)
<< ((float) time)/CLOCKS_PER_SEC << " seconds" << std::endl;
// *************************************************************************
// FOUR PT CONTRACTION 1 ***************************************************
// *************************************************************************
#if 0 //4-point contraction 1
// setting the correlation function to zero
std::cout << "\n\tcomputing the connected contribution of C4_1:\n";
time = clock();
// displacement not supported for 4pt functions atm
displ_min = 0;
displ_max = 0;
std::cout << "\n\tcomputing the connected contribution of C4_1:\n";
time = clock();
// setting the correlation function to zero
for(int p_u = 0; p_u < number_of_momenta; ++p_u)
for(int p_d = 0; p_d < number_of_momenta; ++p_d)
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u)
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d)
for(int t1 = 0; t1 < Lt; ++t1)
C4_mes[p_u][p_d][dirac_u][dirac_d][t1] =
std::complex<double>(0.0, 0.0);
for(int t_source = 0; t_source < Lt; ++t_source){
for(int t_sink = 0; t_sink < Lt; ++t_sink){
int t_source_1 = (t_source + 1) % Lt;
int t_sink_1 = (t_sink + 1) % Lt;
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_u = p_min; p_u < p_max; ++p_u) {
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
// complete diagramm
// every quark line must have its own random vec
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd3 = rnd1 + 1; rnd3 < number_of_rnd_vec; ++rnd3){
for(int rnd2 = 0; rnd2 < number_of_rnd_vec; ++rnd2){
if((rnd2 != rnd1) && (rnd2 != rnd3)){
for(int rnd4 = rnd2 + 1; rnd4 < number_of_rnd_vec; ++rnd4){
if((rnd4 != rnd1) && (rnd4 != rnd3)){
C4_mes[p_u][p_d][dirac_u][dirac_d]
[abs((t_sink - t_source - Lt) % Lt)] +=
(Corr[p_u]
[number_of_momenta - p_d - 1]
[dirac_u][dirac_d][0][0]
[t_source_1][t_sink_1][rnd1][rnd3]) *
(Corr[number_of_momenta - p_u - 1]
[p_d][dirac_u][dirac_d][0][0]
[t_source][t_sink][rnd2][rnd4]);
}
}
}
}
}
}
}
}
}
}
}
}
}
// Normalization of 4pt-function. Accounts for all rnd-number combinations
for(int t = 0; t < Lt; ++t){
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_u = p_min; p_u < p_max; ++p_u) {
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
C4_mes[p_u][p_d][dirac_u][dirac_d][t] /= norm1;
}
}
}
}
}
}
// output to binary file
// see output to binary file for C2.
// write into folders with suffix "_unsuppressed". These only include
// correlators of the diagonal matrix elements of the GEVP for which
// the three-momentum remains unchanged for both quarks. Because the
// quarks have to be back-to-back, for the offdiagonal elements this
// cannot occur. The suppression can be interpreted as Zweig-suppressed
// gluon exchange
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p = 0; p <= max_mom_squared; p++){
sprintf(outfile,
"%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d_unsuppressed/"
"C4_1_conf%04d.dat",
outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d, p, p,
displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = p_min; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p){
fwrite((double*) &(C4_mes[p_u][p_u][dirac_u][dirac_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
fclose(fp);
}
}
}
// to build a GEVP, the correlators are written into a seperate folder
// for every dirac structure, momentum, (entry of the GEVP matrix).
// displacement is not supported at the moment
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p1 = 0; p1 <= max_mom_squared; p1++){
for(int p2 = p1; p2 <= max_mom_squared; p2++){
sprintf(outfile,
"%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d/"
"C4_1_conf%04d.dat",
outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d,
p1, p2, displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = p_min; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p1){
for(int p_d = p_min; p_d < p_max; ++p_d){
if(mom_squared[p_d] == p2){
fwrite((double*) &(C4_mes[p_u][p_d][dirac_u][dirac_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
}
}
fclose(fp);
}
}
}
}
// output to terminal
// printf("\n");
// for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac){
// printf("\tdirac = %02d\n", dirac);
// for(int offset = 0; offset <= max_mom_squared; offset++){
// for(int p = 0; p <= max_mom_squared; p++){
// if((p + offset) <= max_mom_squared){
// for(int p_u = p_min; p_u < p_max; ++p_u){
// if((rewr.mom_squared[p_u] == p) && ((p + offset) <= max_mom_squared)){
// for(int p_d = p_min; p_d < p_max; ++p_d){
// if(rewr.mom_squared[p_d] == (p + offset)){
// //printf(
// // "\t t\tRe(C4_1_con)\tIm(C4_1_con)\n\t----------------------------------\n");
//// for(int t1 = 0; t1 < Lt; ++t1){
//// printf("\t%02d\t%.5e\t%.5e\n", t1, real(C4_mes[p_u][p_d][dirac][dirac][t1]),
//// imag(C4_mes[p_u][p_d][dirac][dirac][t1]));
//// }
// printf("\n");
// printf("p_u = %02d\tp_d = %02d\n", p_u, p_d);
// }
// }
// }
// }
// }
// printf("\n");
// }
// }
// printf("\n");
// }
time = clock() - time;
printf("\t\tSUCCESS - %.1f seconds\n", ((float) time)/CLOCKS_PER_SEC);
#endif // 4-point contraction 1
// *************************************************************************
// FOUR PT CONTRACTION 2 ***************************************************
// *************************************************************************
#if 0 // 4-point contraction 2
// setting the correlation function to zero
std::cout << "\n\tcomputing the connected contribution of C4_2:\n";
time = clock();
for(int p_u = 0; p_u < number_of_momenta; ++p_u)
for(int p_d = 0; p_d < number_of_momenta; ++p_d)
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u)
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d)
for(int t1 = 0; t1 < Lt; ++t1)
C4_mes[p_u][p_d][dirac_u][dirac_d][t1] =
std::complex<double>(0.0, 0.0);
for(int t_source = 0; t_source < Lt; ++t_source){
for(int t_sink = 0; t_sink < Lt - 1; ++t_sink){
int t_source_1 = (t_source + 1) % Lt;
int t_sink_1 = (t_sink + 1) % Lt;
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_u = p_min; p_u < p_max; ++p_u) {
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
// complete diagramm
// every quark line must have its own random vec
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd3 = rnd1 + 1; rnd3 < number_of_rnd_vec; ++rnd3){
for(int rnd2 = 0; rnd2 < number_of_rnd_vec; ++rnd2){
if((rnd2 != rnd1) && (rnd2 != rnd3)){
for(int rnd4 = rnd2 + 1; rnd4 < number_of_rnd_vec; ++rnd4){
if((rnd4 != rnd1) && (rnd4 != rnd3)){
C4_mes[p_u][p_d][dirac_u][dirac_d]
[abs((t_sink - t_source - Lt) % Lt)] +=
(Corr[p_u][number_of_momenta - p_d - 1]
[dirac_u][dirac_d][0][0][t_source_1][t_sink]
[rnd1][rnd3]) *
(Corr[number_of_momenta - p_u - 1][p_d]
[dirac_u][dirac_d][0][0][t_source][t_sink_1]
[rnd2][rnd4]);
}
}
}
}
}
}
}
}
}
}
}
}
}
// Normalization of 4pt-function. Accounts for all rnd-number combinations
for(int t = 0; t < Lt; ++t){
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_u = p_min; p_u < p_max; ++p_u) {
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
C4_mes[p_u][p_d][dirac_u][dirac_d][t] /= norm1;
}
}
}
}
}
}
// output to binary file
// see output to binary file for C2.
// write into folders with suffix "_unsuppressed". These only include
// correlators of the diagonal matrix elements of the GEVP for which
// the three-momentum remains unchanged for both quarks. Because the
// quarks have to be back-to-back, for the offdiagonal elements this
// cannot occur. The suppression can be interpreted as Zweig-suppressed
// gluon exchange
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p = 0; p <= max_mom_squared; p++){
sprintf(outfile,
"%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d_unsuppressed/"
"C4_2_conf%04d.dat",
outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d, p, p,
displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = p_min; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p){
fwrite((double*) &(C4_mes[p_u][p_u][dirac_u][dirac_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
fclose(fp);
}
}
}
// to build a GEVP, the correlators are written into a seperate folder
// for every dirac structure, momentum, (entry of the GEVP matrix).
// displacement is not supported at the moment
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p1 = 0; p1 <= max_mom_squared; p1++){
for(int p2 = p1; p2 <= max_mom_squared; p2++){
sprintf(outfile,
"%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d/"
"C4_2_conf%04d.dat",
outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d,
p1, p2, displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = p_min; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p1){
for(int p_d = p_min; p_d < p_max; ++p_d){
if(mom_squared[p_d] == p2){
fwrite((double*) &(C4_mes[p_u][p_d][dirac_u][dirac_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
}
}
fclose(fp);
}
}
}
}
// output to terminal
// printf("\n");
// for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac){
// printf("\tdirac = %02d\n", dirac);
// for(int offset = 0; offset <= max_mom_squared; offset++){
// for(int p = 0; p <= max_mom_squared; p++){
// if((p + offset) <= max_mom_squared){
// for(int p_u = p_min; p_u < p_max; ++p_u){
// if((rewr.mom_squared[p_u] == p) && ((p + offset) <= max_mom_squared)){
// for(int p_d = p_min; p_d < p_max; ++p_d){
// if(rewr.mom_squared[p_d] == (p + offset)){
// //printf(
// // "\t t\tRe(C4_2_con)\tIm(C4_2_con)\n\t----------------------------------\n");
//// for(int t1 = 0; t1 < Lt; ++t1){
//// printf("\t%02d\t%.5e\t%.5e\n", t1, real(C4_mes[p][p][dirac][dirac][t1]),
//// imag(C4_mes[p][p][dirac][dirac][t1]));
//// }
// printf("\n");
// printf("p_u = %02d\tp_d = %02d\n", p_u, p_d);
// }
// }
// }
// }
// }
// printf("\n");
// }
// }
// printf("\n");
// }
time = clock() - time;
printf("\t\tSUCCESS - %.1f seconds\n", ((float) time)/CLOCKS_PER_SEC);
#endif // 4-point contraction 2
// *************************************************************************
// FOUR PT CONTRACTION 3 ***************************************************
// *************************************************************************
// TODO: check dirac indices. maybe dirac(t_source) and dirac(t_sink) have
// to be equal or there may be four different structures rather than u- and
// d-quark always having the same dirac structure
// doesn't matter as long as all used dirac structures are equal
#if 0 // 4-point contraction 3
std::cout << "\n\tcomputing the connected contribution of C4_3:\n";
time = clock();
// setting the correlation function to zero
for(int p_u = 0; p_u < number_of_momenta; ++p_u)
for(int p_d = 0; p_d < number_of_momenta; ++p_d)
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u)
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d)
for(int t1 = 0; t1 < Lt; ++t1)
C4_mes[p_u][p_d][dirac_u][dirac_d][t1] =
std::complex<double>(0.0, 0.0);
for(int t_source = 0; t_source < Lt; ++t_source){
for(int t_sink = 0; t_sink < Lt; ++t_sink){
int t_source_1 = (t_source + 1) % Lt;
int t_sink_1 = (t_sink + 1) % Lt;
// initialize basic->contraction[]
// p_u = number_of_momenta/2 and the break; statement arrange
// for one-to-all calculation in momentum space. (only one source
// momentum is used. the first five are {(0,0,0), (0,0,1),
// (0,1,-1), (1,-1,-1), (0,0,2)}
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int p = 0; p <= max_mom_squared; p++){
for(int p_u = number_of_momenta/2; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p){
basic->init_operator_u(0, t_source, t_sink, rewr, 'b', p_u, 0);
basic->init_operator_u(1, t_source_1, t_sink_1, rewr, 'b',
number_of_momenta - p_u - 1, 0);
break;
}
}
}
}
// initialize basic->contraction_dagger[]
// build all momenta for sinks
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_d = p_min; p_d < p_max; ++p_d){
basic->init_operator_d(0, t_source_1, t_sink, rewr, 'b', p_d, 0);
basic->init_operator_d(1, t_source, t_sink_1, rewr, 'b',
number_of_momenta - p_d - 1, 0);
}
}
// build 4pt-function C4_mes for pi^+pi^+ Equivalent two just summing
// up the four-trace with same time difference between source and sink
// (all to all) for every dirac structure, momentum
// displacement not supported at the moment
// to build the trace with four matrices, build combinations
// X = D_d^-1(t_sink | t_source + 1)
// Gamma D_u^-1(t_source + 1 | t_sink + 1) Gamma
// Y = D_d^-1(t_sink + 1| t_source)
// Gamma D_u^-1(t_source| t_sink) Gamma
// these have dimension
// (4 * quarks[0].number_of_dilution_E) x (4 *
// quarks[0].number_of_dilution_E)
// thus the multiplication in this order is fastest
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int p = 0; p <= max_mom_squared; p++){
for(int p_u = number_of_momenta / 2; p_u < p_max; ++p_u) {
if(mom_squared[p_u] == p){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p_d = p_min; p_d < p_max; ++p_d) {
if(mom_squared[p_u] <= mom_squared[p_d]){
// initialisation of X. rnd loops and if-statements rule
// forbidden randomvector combinations (to improve
// statistical error never use the same randomvector
// for different indices
basic->get_operator_g5(op_2, 0, dirac_min + dirac_d,
number_of_momenta - p_d - 1);
basic->get_operator_charged(op_3, 1, t_sink_1, &rewr,
dirac_min + dirac_u, number_of_momenta - p_u - 1);
// second u quark: t_source_1 -> t_sink_1
for(int rnd3 = 1; rnd3 < number_of_rnd_vec; ++rnd3){
for(int rnd2 = 0; rnd2 < number_of_rnd_vec; ++rnd2){
if(rnd2 != rnd3){
// first d quark: t_sink_1 -> t_source
for(int rnd4 = rnd2 + 1; rnd4 < number_of_rnd_vec; ++rnd4){
if(rnd4 != rnd3){
X[rnd3][rnd2][rnd4] = op_2[rnd3] *
op_3[rnd2][rnd4] ;
}
}
}
}
}
// initialisation of Y. see initialisation of X
basic->get_operator_g5(op_4, 1, dirac_min + dirac_d, p_d);
basic->get_operator_charged(op_1, 0, t_sink, rewr,
dirac_min + dirac_u, p_u);
// first u quark: t_source -> t_sink
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd3 = rnd1 + 1; rnd3 < number_of_rnd_vec; ++rnd3){
// second d quark: t_sink -> t_source_1
for(int rnd4 = 1; rnd4 < number_of_rnd_vec; ++rnd4){
if((rnd4 != rnd1) && (rnd4 != rnd3)){
Y[rnd4][rnd1][rnd3] = op_4[rnd4] *
op_1[rnd1][rnd3];
}
}
}
}
// complete diagramm. combine X and Y to four-trace
// C4_mes = tr(D_u^-1(t_source| t_sink) Gamma
// D_d^-1(t_sink | t_source + 1) Gamma
// D_u^-1(t_source + 1 | t_sink + 1) Gamma
// D_d^-1(t_sink + 1| t_source) Gamma)
// every quark line must have its own random vec
for(int rnd1 = 0; rnd1 < number_of_rnd_vec; ++rnd1){
for(int rnd3 = rnd1 + 1; rnd3 < number_of_rnd_vec; ++rnd3){
for(int rnd2 = 0; rnd2 < number_of_rnd_vec; ++rnd2){
if((rnd2 != rnd1) && (rnd2 != rnd3)){
for(int rnd4 = rnd2 + 1; rnd4 < number_of_rnd_vec; ++rnd4){
if((rnd4 != rnd1) && (rnd4 != rnd3)){
C4_mes[p_u][p_d][dirac_u][dirac_d]
[abs((t_sink - t_source - Lt) % Lt)] +=
((X[rnd3][rnd2][rnd4] *
Y[rnd4][rnd1][rnd3]).trace());
}
}
}
}
}
}
}
}
}
break;
}
}
}
}
}
}
// Normalization of 4pt-function. Accounts for all rnd-number combinations
for(int p1 = 0; p1 < number_of_momenta; ++p1)
for(int p2 = 0; p2 < number_of_momenta; ++p2)
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u)
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d)
for(int t = 0; t < Lt; ++t)
C4_mes[p1][p2][dirac_u][dirac_d][t] /= norm1;
// output to binary file
// see output to binary file for C2.
// for the C4_3 diagram the four propagators are connected in the same
// trace. Thus there are no gluon lines which could be cut to create a
// disconnected diagrams and thus no Zweig suppression.
// To build a GEVP, the correlators are written into a seperate folder
// for every dirac structure, momentum, (entry of the GEVP matrix).
// displacement is not supported at the moment
for(int dirac_u = 0; dirac_u < number_of_dirac; ++dirac_u){
for(int dirac_d = 0; dirac_d < number_of_dirac; ++dirac_d){
for(int p1 = 0; p1 <= max_mom_squared; p1++){
for(int p2 = p1; p2 <= max_mom_squared; p2++){
sprintf(outfile,
"%s/dirac_%02d_%02d_p_%01d_%01d_displ_%01d_%01d/"
"C4_3_conf%04d.dat",
outpath.c_str(), dirac_min + dirac_u, dirac_min + dirac_d,
p1, p2, displ_min, displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int p_u = number_of_momenta / 2; p_u < p_max; ++p_u){
if(mom_squared[p_u] == p1){
for(int p_d = p_min; p_d < p_max; ++p_d){
if(mom_squared[p_d] == p2){
fwrite((double*) &(C4_mes[p_u][p_d][dirac_u][dirac_d][0]),
sizeof(double), 2 * Lt, fp);
}
}
break;
}
}
fclose(fp);
}
}
}
}
#if 0
sprintf(outfile,
"%s/dirac_%02d_%02d_p_0_%01d_displ_%01d_%01d/C4_3_conf%04d.dat",
outpath.c_str(), dirac_min, dirac_max, 0, displ_min,
displ_max, config_i);
if((fp = fopen(outfile, "wb")) == NULL)
std::cout << "fail to open outputfile" << std::endl;
for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac)
fwrite((double*) C4_mes[number_of_momenta/2]
[number_of_momenta/2][dirac][dirac], sizeof(double), 2 * Lt, fp);
fclose(fp);
#endif
// output to terminal
// printf("\n");
// for(int dirac = dirac_min; dirac < dirac_max + 1; ++dirac){
// printf("\tdirac = %02d\n", dirac);
// for(int p = p_min; p < p_max; ++p) {
// printf("\tmomentum = %02d\n", p);
// //printf(
// // "\t t\tRe(C4_3_con)\tIm(C4_3_con)\n\t----------------------------------\n");
// for(int t1 = 0; t1 < Lt; ++t1){
// printf("\t%02d\t%.5e\t%.5e\n", t1, real(C4_mes[p][p][dirac][dirac][t1]),
// imag(C4_mes[p][p][dirac][dirac][t1]));
// }
// printf("\n");
// }
// printf("\n");
// }
time = clock() - time;
printf("\t\tSUCCESS - %.1f seconds\n", ((float) time)/CLOCKS_PER_SEC);
#endif // 4-point contraction 3
// *************************************************************************
// FOUR PT CONTRACTION 4 ***************************************************
// *************************************************************************
// identical to FOUR PT CONTRACTION 3
} // loop over configs ends here
// TODO: freeing all memory!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
delete rewr;
delete basic;
}
