static void edge_cases( struct resampled *effmass , const struct resampled *bootavg , const size_t j , const size_t NDATA ) { if( j == 0 ) { equate( &effmass[j] , bootavg[j+1] ) ; divide( &effmass[j] , bootavg[j] ) ; if( log_range( effmass[j] ) ) { zero_effmass( &effmass[j] , bootavg[j] ) ; } else { res_log( &effmass[j] ) ; mult_constant( &effmass[j] , -1.0 ) ; } } else if( j == NDATA - 1 ) { equate( &effmass[j] , bootavg[j] ) ; divide( &effmass[j] , bootavg[j-1] ) ; // just in case there is a sign flip if( log_range( effmass[j] ) ) { return zero_effmass( &effmass[j] , bootavg[j] ) ; } else { res_log( &effmass[j] ) ; mult_constant( &effmass[j] , -1.0 ) ; } } return ; }
static void average_data( struct resampled *ave , const struct resampled *to_add , const int NDATA ) { size_t j ; for( j = 0 ; j < NDATA ; j++ ) { add( &ave[j] , to_add[j] ) ; mult_constant( &ave[j] , 0.5 ) ; } }
// tauvus computation void flavour_combination_eval( double **xavg , struct resampled **bootavg , struct mom_info **mominfo , struct input_params *INPARAMS , const int NSLICES , const int LT , const bool renormalise ) { printf( "\n--> Flavour combination evaluation <--\n" ) ; // tell us if we have given the wrong arguments if( NSLICES != 4 ) { printf( "Expected V (ss) VV(ls) A(ll) A(ls)\n" ) ; return ; } printf( "\n--> Converting to physical momenta <--\n" ) ; // OK, momentum first int j , i ; for( j = 0 ; j < NSLICES ; j++ ) { // ainverse multipliers const double aI = INPARAMS -> quarks[j].ainverse ; const double aI2 = pow( INPARAMS -> quarks[j].ainverse , 2 ) ; const double aI4 = pow( INPARAMS -> quarks[j].ainverse , 4 ) ; const double aI6 = pow( INPARAMS -> quarks[j].ainverse , 6 ) ; #pragma omp parallel for private(i) for( i = 0 ; i < INPARAMS -> NDATA[j] ; i++ ) { // set to physical lattice spacing xavg[j][i] is now |p| in GeV!! xavg[j][i] = aI * sqrt( xavg[j][i] ) ; // and the moms mominfo[j][i].p2 *= aI2 ; mominfo[j][i].p4 *= aI4 ; mominfo[j][i].p6 *= aI6 ; // check for some consistency if( fabs( mominfo[j][i].p2 - xavg[j][i]*xavg[j][i] ) > 1E-12 ) { printf( "P2 Broken !! %e \n" , mominfo[j][i].p2 - xavg[j][i]*xavg[j][i] ) ; exit(1) ; } } } // multiply by Z_V printf( "\n--> Renormalising <--\n" ) ; char str[ 256 ] ; sprintf( str , "m%g_m%g.dat" , INPARAMS -> quarks[1].ml , INPARAMS -> quarks[1].ms ) ; FILE *file = fopen( str , "w" ) ; // so the idea is to form all contributions into bootavg[0] const double ZV = INPARAMS -> quarks[0].ZV ; fprintf( file , "ZV :: %f\n" , INPARAMS -> quarks[0].ZV ) ; fprintf( file , "a^{-1} :: %f GeV\n" , INPARAMS -> quarks[0].ainverse ) ; fprintf( file , "Combination :: ( ss - ls )_V + ( ll - ls )_A (0+1) \n" ) ; fprintf( file , "q [GeV] Pi(q^2) Err\n" ) ; printf( "Renormalising with %f \n" , ZV ) ; // form flavour breaking combination for( j = 0 ; j < INPARAMS->NDATA[0] ; j++ ) { // form V(0+1) -(ss-ls) put in index 0 subtract( &bootavg[0][j] , bootavg[1][j] ) ; // form A (0+1)-(ll-ls) and put in index 2 subtract( &bootavg[2][j] , bootavg[3][j] ) ; // and compute the flavour breaking difference add( &bootavg[0][j] , bootavg[2][j] ) ; // and then renormalise mult_constant( &bootavg[0][j] , ZV ) ; fprintf( file , "%f %1.12E %1.12E \n" , xavg[0][j] , bootavg[0][j].avg , bootavg[0][j].err ) ; } // plot only the flavour breaking difference struct resampled *fitparams = fit_data_plot_data( (const struct resampled**)bootavg , (const double**)xavg , (const struct mom_info **)mominfo , *INPARAMS , 1 , LT ) ; fclose( file ) ; free( fitparams ) ; return ; }
// tetra computation void tetra_eval( double **xavg , struct resampled **bootavg , struct mom_info **mominfo , struct mom_info *moms , struct input_params *INPARAMS , const int NSLICES , const int LT ) { // Diquark-Diquark is in Slice #0 and Dimeson is in #1 // Vector Meson is in #2 // Pseudoscalar Meson is in #3 size_t j ; #ifdef COMPUTE_BINDING if( NSLICES == 4 ) { // take product of vector and pseudoscalar put into 2 for( j = 0 ; j < INPARAMS -> NDATA[2] ; j++ ) { mult( &bootavg[2][j] , bootavg[3][j] ) ; mult_constant( &bootavg[2][j] , -1 ) ; } } else if( NSLICES == 8 ) { // take product of vector and pseudoscalar for( j = 0 ; j < INPARAMS -> NDATA[2] ; j++ ) { mult( &bootavg[2][j] , bootavg[3][j] ) ; mult_constant( &bootavg[2][j] , -1 ) ; mult( &bootavg[6][j] , bootavg[7][j] ) ; mult_constant( &bootavg[6][j] , -1 ) ; } // backwards data needs to b time flipped flip_data( bootavg[3] , bootavg[4] , INPARAMS -> NDATA[4] ) ; flip_data( bootavg[4] , bootavg[5] , INPARAMS -> NDATA[4] ) ; flip_data( bootavg[5] , bootavg[6] , INPARAMS -> NDATA[4] ) ; // average the data average_data( bootavg[0] , bootavg[3] , INPARAMS -> NDATA[0] ) ; average_data( bootavg[1] , bootavg[4] , INPARAMS -> NDATA[0] ) ; average_data( bootavg[2] , bootavg[5] , INPARAMS -> NDATA[0] ) ; } for( j = 0 ; j < INPARAMS -> NDATA[2] ; j++ ) { // divide correlator #0 by this result divide( &bootavg[0][j] , bootavg[2][j] ) ; divide( &bootavg[1][j] , bootavg[2][j] ) ; } // evaluate the correlator now correlator_eval( xavg , bootavg , mominfo , moms , INPARAMS , 2 , LT ) ; #else // take product of vector and pseudoscalar put into 2 for( j = 0 ; j < INPARAMS -> NDATA[2] ; j++ ) { mult( &bootavg[2][j] , bootavg[3][j] ) ; mult_constant( &bootavg[2][j] , -1 ) ; } // evaluate the correlator now correlator_eval( xavg , bootavg , mominfo , moms , INPARAMS , 3 , LT ) ; #endif return ; }
double* reconstruction(PSIRT* psirt) { int i=0; //for(i=0;i<n_particulas;i++) printf("\r\nDONE\tPARTICLE #%d STATUS: %d",i,particles[i]->status); // --- // 1. AJUSTAR ESCOPO // O universo de particulas esta inicialmente entre -1 e +1. // Ajustar de acordo com o fator de escala. // --- for (i = 0; i < psirt->n_particles; i++) { if ((psirt->particles[i]->location->x > -RECONSTRUCTION_SCALE_FACTOR) && (psirt->particles[i]->location->x < RECONSTRUCTION_SCALE_FACTOR) && (psirt->particles[i]->location->y > -RECONSTRUCTION_SCALE_FACTOR) && (psirt->particles[i]->location->y < RECONSTRUCTION_SCALE_FACTOR)) { psirt->particles[i]->location->x += RECONSTRUCTION_SCALE_FACTOR; psirt->particles[i]->location->y += RECONSTRUCTION_SCALE_FACTOR; psirt->particles[i]->location->x /= 2 * RECONSTRUCTION_SCALE_FACTOR; psirt->particles[i]->location->y /= 2 * RECONSTRUCTION_SCALE_FACTOR; } } // --- // 2. ESCALAR // Escalar particulas de acordo com resolucao. // --- Vector2D** scaled_particles = malloc(sizeof(Vector2D*) * psirt->n_particles); for (i = 0; i < psirt->n_particles; i++) { scaled_particles[i] = mult_constant(psirt->particles[i]->location, RES_X); //printf("\r\n ANTES: %f,%f \t DEPOIS: %f,%f",particles[i]->location->x, particles[i]->location->y,scaled_particles[i]->x,scaled_particles[i]->y ); } // --- // 3. CALCULAR INTENSIDADE DE CADA PIXEL // Para cada pixel, medir a distancia entre seu centro // e cada particula presente no sistema. // --- double *pixel_intensity = malloc(sizeof(double) * RES_X * RES_Y); for (i = 0; i < RES_X * RES_Y; i++) pixel_intensity[i] = 0.0; Vector2D* pixel = new_vector(0.0, 0.0); int pix_x = 0, pix_y = 0, part = 0; double iter_intensity = 0.0; for (pix_x = 0; pix_x < RES_X; pix_x++) { for (pix_y = 0; pix_y < RES_Y; pix_y++) { // atualiza pixel atual (centro: bias +0.5, +0.5) set_vector(pixel, pix_x + 0.5, pix_y + 0.5); int particula = -1; // distancia para cada particula for (part = 0; part < psirt->n_particles; part++) { if (psirt->particles[part]->status != DEAD) { // formato: x + ( y*RES_X ) double distance = vector_vector_distance(pixel, scaled_particles[part]); //!!!!!!!!!!!!!!!!! // if (particula == -1) particula = part; // // else if (part != particula) // { // if ( (scaled_particles[part]->x > scaled_particles[particula]->x) // & // ( (fabs(scaled_particles[part]->y - scaled_particles[particula]->y ) <= TRAJ_PART_THRESHOLD*RES_X ) ) ) // { // printf("\r\nParticula fixa: [%d] (%f,%f)\t comparada com [%d] (%f,%f)\t DIST = %f", // particula, scaled_particles[particula]->x, scaled_particles[particula]->y, // part, scaled_particles[part]->x, scaled_particles[part]->y, // distance); // } // } if (distance > PARTICLE_SIZE) { distance = 0.0; iter_intensity = 0.0; } else { distance = ((PARTICLE_SIZE - distance) / PARTICLE_SIZE); // distance= distance/PARTICLE_SIZE; // distance = 1-distance; iter_intensity = distance; //TODO interf. destrutiva? // iter_intensity = // (iter_intensity > SATURATION) ? SATURATION : iter_intensity; } if (iter_intensity > 0) pixel_intensity[pix_x + (pix_y * RES_X)] += iter_intensity; } } } } free(scaled_particles); free(pixel); double max = -1.0, min = 999999.0, delta = 0; for (i = 0; i < RES_X * RES_Y; i++) { if (pixel_intensity[i] > max) max = pixel_intensity[i]; else if (pixel_intensity[i] < min) min = pixel_intensity[i]; // if (i%RES_X==0) printf("\r\n"); // printf("%f ",pixel_intensity[i]); } delta = max - min; // normalize for (i = 0; i < RES_X * RES_Y; i++) { pixel_intensity[i] -= min; pixel_intensity[i] /= delta; } return pixel_intensity; }