int main(){
static vec u(K+1), un(K+1);
val dt = T/N;
val dx = 1.0/K;
val gam = MU*dt/(dx*dx);
val rho = NU*dt/(dx*dx*dx*dx);
val ar = dt/(2*dx);
int j,n=1;
//Initialize U
for (j=0;j<K+1;j++) u(j)=f(j*dx);
//printf("Initial vector\n"); vecprintf(u,K);
val tn = n*dt;
while (tn<=T||n<N){
for (j=0;j<K+1;j++) un(j) = u(j) - gam*delta2(u,j) - rho*delta4(u,j) - ar*u(j)*delta0(u,j);
for (j=0;j<K+1;j++) u(j) = un(j);
n+=1;
tn = n*dt;
}
printf("At t = 0.25 and space 0.5 the 'heat' is %24.15e\n", u(K/2));
return 0;
}
void LinearQuadtreeExpansion::M2L(__uint32 source, __uint32 receiver)
{
double* receiv_coeff = m_localExp + receiver*(m_numCoeff<<1);
double* source_coeff = m_multiExp + source*(m_numCoeff<<1);
const float center_x_source = (float)m_tree.nodeX(source);
const float center_y_source = (float)m_tree.nodeY(source);
const float center_x_receiver = (float)m_tree.nodeX(receiver);
const float center_y_receiver = (float)m_tree.nodeY(receiver);
ComplexDouble center_receiver(center_x_receiver, center_y_receiver);
ComplexDouble center_source(center_x_source, center_y_source);
ComplexDouble delta0(center_source - center_receiver);
ComplexDouble delta1 = -delta0;
ComplexDouble delta1_l(delta1);
ComplexDouble a;
ComplexDouble a0(source_coeff);
ComplexDouble b;
ComplexDouble sum;
for (__uint32 l=1;l<m_numCoeff;l++)
{
b.load(receiv_coeff+(l<<1));
sum = a0*(-1/(double)l);
ComplexDouble delta0_k(delta0);
for (__uint32 k=1;k<m_numCoeff;k++)
{
a.load(source_coeff+(k<<1));
sum += (a*binCoef.value(l+k-1, k-1)) / delta0_k;
delta0_k *= delta0;
};
b += sum/delta1_l;
b.store(receiv_coeff+(l<<1));
delta1_l *= delta1;
};
// b0
b.load(receiv_coeff);
//std::complex<double> sdelta(m_center[(receiver<<1)] - m_center[(source<<1)], m_center[(receiver<<1)+1] - m_center[(source<<1) +1]);//, m_x[receiver] - m_x[source], m_y[receiver] - m_y[source]);
/*std::complex<double> sdelta(center_x_receiver - center_x_source,
center_y_receiver - center_y_source);//, m_x[receiver] - m_x[source], m_y[receiver] - m_y[source]);
if ((sdelta.real() <=0) && (sdelta.imag() == 0)) //no cont. compl. log fct exists !!!
sdelta = log(sdelta + 0.00000001);
else
sdelta = log(sdelta);
*/
double r = delta1.length();//= sqrt(sdelta.real()*sdelta.real()+sdelta.imag()*sdelta.imag());
double phi = atan((center_x_receiver - center_x_source)/(center_y_receiver - center_y_source));
// sum = a0*log(z1 - z0)
b += a0*ComplexDouble(log(r), phi);
// (z1 - z0)^1
//b += a0*ComplexDouble(sdelta.real(), sdelta.imag());
delta1_l = delta1;
for (__uint32 k=1;k<m_numCoeff;k++)
{
a.load(source_coeff+(k<<1));
b += a/delta1_l;
//(z1 - z0)^k
delta1_l *= delta1;
};
b.store(receiv_coeff);
};
int main()
{
struct parameters param;
Init_param(¶m);
slha_adjust(¶m);
param.SM=1;
printf("\n");
printf("SuperIso v3.4 - F. Mahmoudi\n\n");
printf("Standard Model predictions\n\n");
printf("Observable\t\t\tValue\n\n");
double C0b[11],C0spec[11],C1b[11],C1spec[11],C0w[11],C1w[11],C2w[11],C2b[11],Cpb[11];
double complex CQpb[3],CQ0b[3],CQ1b[3];
CQ0b[1]=CQ0b[2]=CQ1b[1]=CQ1b[2]=CQpb[1]=CQpb[2]=0.;
double obs[Nobs_BKsll+1];
double mu_W=2.*param.mass_W;
double mu_b=param.mass_b_pole/2.;
CW_calculator(C0w,C1w,C2w,mu_W,¶m);
C_calculator_base1(C0w,C1w,C2w,mu_W,C0b,C1b,C2b,mu_b,¶m);
Cprime_calculator(Cpb,CQpb,mu_W,mu_b,¶m);
printf("BR(b->s gamma)\t\t\t%.3e\n",bsgamma(C0b,C1b,C2b,Cpb,mu_b,mu_W,¶m));
double lambda_h=0.5;
double mu_spec=sqrt(lambda_h*mu_b);
C_calculator_base2(C0w,C1w,mu_W,C0b,C1b,mu_b,¶m);
C_calculator_base2(C0w,C1w,mu_W,C0spec,C1spec,mu_spec,¶m);
Cprime_calculator(Cpb,CQpb,mu_W,mu_b,¶m);
printf("delta0(B->K* gamma)\t\t%.3e\n\n",delta0(C0b,C0spec,C1b,C1spec,Cpb,¶m,mu_b,mu_spec));
mu_b=param.mass_b_pole;
C_calculator_base1(C0w,C1w,C2w,mu_W,C0b,C1b,C2b,mu_b,¶m);
Cprime_calculator(Cpb,CQpb,mu_W,mu_b,¶m);
printf("BR(Bs->mu mu)\t\t\t%.3e\n",Bsmumu(C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("BR(Bs->mu mu)_untag\t\t%.3e\n",Bsmumu_untag(C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("BR(Bd->mu mu)\t\t\t%.3e\n\n",Bdmumu(C0b,C1b,C2b,CQ0b,CQ1b,¶m,mu_b));
printf("BR(B->K* mu mu)_low\t\t%.3e\n",BRBKstarmumu(1.,6.,obs,C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("AFB(B->K* mu mu)_low\t\t%.3e\n",obs[1]);
printf("FL(B->K* mu mu)_low\t\t%.3e\n",obs[2]);
printf("P1=AT1(B->K* mu mu)_low\t\t%.3e\n",obs[4]);
printf("AT2(B->K* mu mu)_low\t\t%.3e\n",obs[5]);
printf("AT3(B->K* mu mu)_low\t\t%.3e\n",obs[6]);
printf("AT4(B->K* mu mu)_low\t\t%.3e\n",obs[7]);
printf("AT5(B->K* mu mu)_low\t\t%.3e\n",obs[8]);
printf("P4=HT1(B->K* mu mu)_low\t\t%.3e\n",obs[9]);
printf("P5=HT2(B->K* mu mu)_low\t\t%.3e\n",obs[10]);
printf("HT3(B->K* mu mu)_low\t\t%.3e\n",obs[11]);
printf("P2(B->K* mu mu)_low\t\t%.3e\n",obs[14]);
printf("P3(B->K* mu mu)_low\t\t%.3e\n",obs[15]);
printf("P6(B->K* mu mu)_low\t\t%.3e\n",obs[16]);
printf("P4'(B->K* mu mu)_low\t\t%.3e\n",obs[17]);
printf("P5'(B->K* mu mu)_low\t\t%.3e\n",obs[18]);
printf("P6'(B->K* mu mu)_low\t\t%.3e\n",obs[19]);
printf("P8(B->K* mu mu)_low\t\t%.3e\n",obs[20]);
printf("P8'(B->K* mu mu)_low\t\t%.3e\n",obs[21]);
printf("AI(B->K* mu mu)_low\t\t%.3e\n\n",AI_BKstarmumu_lowq2(C0b,C1b,C2b,¶m,mu_b));
printf("BR(B->K* mu mu)_high\t\t%.3e\n",BRBKstarmumu_highq2(obs,C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("AFB(B->K* mu mu)_high\t\t%.3e\n",obs[1]);
printf("FL(B->K* mu mu)_high\t\t%.3e\n",obs[2]);
printf("AT1(B->K* mu mu)_high\t\t%.3e\n",obs[4]);
printf("P1=AT2(B->K* mu mu)_high\t%.3e\n",obs[5]);
printf("AT3(B->K* mu mu)_high\t\t%.3e\n",obs[6]);
printf("AT4(B->K* mu mu)_high\t\t%.3e\n",obs[7]);
printf("AT5(B->K* mu mu)_high\t\t%.3e\n",obs[8]);
printf("P4=HT1(B->K* mu mu)_high\t%.3e\n",obs[9]);
printf("P5=HT2(B->K* mu mu)_high\t%.3e\n",obs[10]);
printf("HT3(B->K* mu mu)_high\t\t%.3e\n",obs[11]);
printf("P2(B->K* mu mu)_high\t\t%.3e\n",obs[14]);
printf("P3(B->K* mu mu)_high\t\t%.3e\n",obs[15]);
printf("P6(B->K* mu mu)_high\t\t%.3e\n",obs[16]);
printf("P4'(B->K* mu mu)_high\t\t%.3e\n",obs[17]);
printf("P5'(B->K* mu mu)_high\t\t%.3e\n",obs[18]);
printf("P6'(B->K* mu mu)_high\t\t%.3e\n",obs[19]);
printf("P8(B->K* mu mu)_high\t\t%.3e\n",obs[20]);
printf("P8'(B->K* mu mu)_high\t\t%.3e\n",obs[21]);
printf("AI(B->K* mu mu)_high\t\t%.3e\n\n",AI_BKstarmumu_highq2(C0b,C1b,C2b,¶m,mu_b));
double smin=pow(2.*param.mass_mu,2.);
double smax=pow(param.m_Bd-param.m_Kstar,2.)*0.999;
BRBKstarmumu(smin,smax,obs,C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b);
printf("q0^2(AFB(B->K* mu mu))\t\t%.3e\n",obs[0]);
printf("q0^2(AI(B->K* mu mu))\t\t%.3e\n\n",AI_BKstarmumu_zero(C0b,C1b,C2b,¶m,mu_b));
printf("BR(B->Xs mu mu)_low\t\t%.3e\n",BRBXsmumu_lowq2(C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("BR(B->Xs mu mu)_high\t\t%.3e\n",BRBXsmumu_highq2(C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("q0^2(AFB(B->Xs mu mu)\t\t%.3e\n",A_BXsmumu_zero(C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("BR(B->Xs tau tau)_high\t\t%.3e\n\n",BRBXstautau_highq2(C0b,C1b,C2b,CQ0b,CQ1b,Cpb,CQpb,¶m,mu_b));
printf("BR(B->tau nu)\t\t\t%.3e\n",Btaunu(¶m));
printf("R(B->tau nu)\t\t\t%.3e\n",RBtaunu(¶m));
printf("BR(B->D tau nu)\t\t\t%.3e\n",BDtaunu(¶m));
printf("BR(B->D tau nu)/BR(B->D e nu)\t%.3e\n",BDtaunu_BDenu(¶m));
printf("BR(Ds->tau nu)\t\t\t%.3e\n",Dstaunu(¶m));
printf("BR(Ds->mu nu)\t\t\t%.3e\n",Dsmunu(¶m));
printf("BR(D->mu nu)\t\t\t%.3e\n",Dmunu(¶m));
printf("BR(K->mu nu)/BR(pi->mu nu)\t%.3e\n",Kmunu_pimunu(¶m));
printf("Rmu23(K->mu nu)\t\t\t%.3e\n\n",Rmu23(¶m));
return 1;
}
int main(int np, char** p)
{
double * current, *error;
double * current_pre, *error_pre;//preliminary input
int i,j,k,t;
FILE* file_in_current;
FILE* file_in_matrix;
FILE* file_out;
FILE* file_out_excl;
FILE* file_const;
int par_int;
double par_double;
double int_result, int_error;
double center;
double omega;
gsl_vector * R;
gsl_vector * omega_R; //for real center definition
gsl_vector * Q;
gsl_vector * Q_initial;
gsl_matrix * S;//covariance matrix
gsl_matrix * S_pre;//covariance matrix (preliminary input)
file_in_current=fopen(p[2],"r");
file_in_matrix=fopen(p[3],"r");
sprintf(directory,"%s", p[4]);
Nt_2=atoi(p[1]);
dNt_2=(double) Nt_2;
//reading parameters file
file_const=fopen(p[5],"r");
//double accuracy=1e-8;
parse_option(file_const,"%le",&accuracy);
//long int N_int_steps=1000000;
parse_option(file_const,"%ld",&N_int_steps);
//double omega_plot_delta=0.01;
parse_option(file_const,"%le",&omega_plot_delta);
//double omega_plot_limit=30.0;
parse_option(file_const,"%le",&omega_plot_limit);
//double lambda=1.0;
parse_option(file_const,"%le",&lambda);
//double center_start=3.0;
parse_option(file_const,"%le",¢er_start);
//double center_stop=18.01;
parse_option(file_const,"%le",¢er_stop);
//double center_delta=3.0;
parse_option(file_const,"%le",¢er_delta);
//int flag_exclude
parse_option(file_const,"%d",&flag_exclude_delta);
//int count_start
parse_option(file_const,"%d",&count_start_exclude);
//int flag_model
parse_option(file_const,"%d",&flag_model);
if(flag_model==1)
{
fscanf(file_const, "%d", &N_valid_points);
points_numbers=(int*) calloc(N_valid_points, sizeof(int));
for(i=0;i<N_valid_points; i++)
fscanf(file_const, "%d", &(points_numbers[i]));
}
else
{
N_valid_points=Nt_2;
points_numbers=(int*) calloc(N_valid_points, sizeof(int));
for(i=0;i<N_valid_points; i++)
points_numbers[i]=i+1;
}
fclose(file_const);
file_out=fopen_control("parameters.txt","w");
fprintf(file_out,"number of points (=half of physical number of timeslices)=%d\n", Nt_2);
fprintf(file_out,"file with current correlator:\n %s\n", p[2]);
fprintf(file_out,"file with covariance matrix:\n %s\n", p[3]);
fprintf(file_out,"path for output:\n %s\n", p[4]);
fprintf(file_out,"file with parameters:\n %s\n", p[5]);
//double accuracy=1e-8;
fprintf(file_out,"accuracy=%.15le\n",accuracy);
//long int N_int_steps=1000000;
fprintf(file_out,"Number os steps in numerical interation=%ld\n",N_int_steps);
//double omega_plot_delta=0.01;
fprintf(file_out,"Step in plots of resolution function(omega)=%.15le\n",omega_plot_delta);
//double omega_plot_limit=30.0;
fprintf(file_out,"Limit in plots of resolution function(omega)=%.15le\n",omega_plot_limit);
//double lambda=1.0;
fprintf(file_out,"Lambda(regularization)=%.15le\n(=1 - without regularization)\n",lambda);
//double center_start=3.0;
fprintf(file_out,"Center of resolution function starts from = %.15le\n",center_start);
//double center_stop=18.01;
fprintf(file_out,"Center of resolution function stops at %.15le\n",center_stop);
//double center_delta=3.0;
fprintf(file_out,"Step in center of resolution function = %.15le\n",center_delta);
//flag_exclude_delta;
fprintf(file_out,"TExclude or not (1 or 0) initial delta finction %d\n",flag_exclude_delta);
//count_start_exclude
fprintf(file_out,"Number of iteration for center to start exclusion of initial delta-function = %d\n",count_start_exclude);
//model_flag;
fprintf(file_out,"Take into account all (0) or not all (1) timeslices = %d\n",flag_model);
if(flag_model==1)
{
fprintf(file_out,"Number of timeslices taken into account = %d\n",N_valid_points);
for(i=0;i<N_valid_points;i++)
{
fprintf(file_out,"%d\n",points_numbers[i]);
}
}
fclose(file_out);
current_pre=(double*) calloc(Nt_2, sizeof(double));
error_pre=(double*) calloc(Nt_2, sizeof(double));
S_pre=gsl_matrix_calloc(Nt_2, Nt_2);
for(t=1;t<=Nt_2;t++)
{
fscanf(file_in_current, "%d", &par_int);
fscanf(file_in_current, "%le", &par_double);
current_pre[t-1]=par_double;
fscanf(file_in_current, "%le", &par_double);
error_pre[t-1]=par_double;
}
fclose(file_in_current);
file_out=fopen_control("current_control_pre.txt","w");
for(t=0;t<Nt_2;t++)
{
fprintf(file_out,"%d\t%.15le\t%.15le\n", t, current_pre[t], error_pre[t]);
}
fclose(file_out);
for(i=1;i<=Nt_2;i++)
for(t=1;t<=Nt_2;t++)
{
fscanf(file_in_matrix, "%le", &par_double);
gsl_matrix_set(S_pre, i-1, t-1, par_double);
}
fclose(file_in_matrix);
file_out=fopen_control("cov_matrix_control_pre.txt","w");
for(i=0;i<Nt_2;i++){
for(t=0;t<Nt_2;t++)
{
fprintf(file_out,"%.15le\t", gsl_matrix_get(S_pre, i,t));
}
fprintf(file_out,"\n");
}
fclose(file_out);
//conversion to real arrays taken into account only certain timeslices
///////////////////////////////////////////
///////////////////////////////////////////
///////////////////////////////////////////
{
int count1, count2;
Nt_2_pre=Nt_2;
dNt_2_pre=(double) Nt_2_pre;
if(flag_model==1)
{
Nt_2=N_valid_points;
dNt_2=(double)Nt_2;
}
current=(double*) calloc(Nt_2, sizeof(double));
error=(double*) calloc(Nt_2, sizeof(double));
S=gsl_matrix_calloc(Nt_2, Nt_2);
for(count1=0;count1<Nt_2;count1++)
{
current[count1]=current_pre[points_numbers[count1]-1];
error[count1]=error_pre[points_numbers[count1]-1];
}
fclose(file_in_current);
file_out=fopen_control("current_control_fin.txt","w");
for(t=0;t<Nt_2;t++)
{
fprintf(file_out,"%d\t%.15le\t%.15le\n", points_numbers[t], current[t], error[t]);
}
fclose(file_out);
for(count1=0;count1<Nt_2;count1++)
for(count2=0;count2<Nt_2;count2++)
{
par_double=gsl_matrix_get(S_pre,points_numbers[count1]-1, points_numbers[count2]-1);
gsl_matrix_set(S, count1, count2, par_double);
}
fclose(file_in_matrix);
file_out=fopen_control("cov_matrix_control.txt","w");
for(i=0;i<Nt_2;i++){
for(t=0;t<Nt_2;t++)
{
fprintf(file_out,"%.15le\t", gsl_matrix_get(S, i,t));
}
fprintf(file_out,"\n");
}
fclose(file_out);
}
//end of conversion
///////////////////////////////////////////
///////////////////////////////////////////
///////////////////////////////////////////
//integration to obtain R vector
file_out=fopen_control("R_control.txt","w");
R=gsl_vector_alloc(Nt_2);
{
gsl_integration_workspace * w = gsl_integration_workspace_alloc (N_int_steps);
gsl_function F;
F.function = &kernel_int;
for(t=1;t<=Nt_2;t++)
{
F.params = &t;
gsl_integration_qagiu (&F, 0.0, accuracy, accuracy, N_int_steps, w, &int_result, &int_error);
gsl_vector_set(R,t-1,int_result);
fprintf(file_out,"%d\t%.15le\t%.15le\n", t, int_result, int_error); fflush(file_out);
}
gsl_integration_workspace_free (w);
}
fclose(file_out);
///////
//integration to obtain omega_R vector
file_out=fopen_control("omega_R_control.txt","w");
omega_R=gsl_vector_alloc(Nt_2);
{
gsl_integration_workspace * w = gsl_integration_workspace_alloc (N_int_steps);
gsl_function F;
F.function = &omega_kernel_int;
for(t=1;t<=Nt_2;t++)
{
F.params = &t;
gsl_integration_qagiu (&F, 0.0, accuracy, accuracy, N_int_steps, w, &int_result, &int_error);
gsl_vector_set(omega_R,t-1,int_result);
fprintf(file_out,"%d\t%.15le\t%.15le\n", t, int_result, int_error); fflush(file_out);
}
gsl_integration_workspace_free (w);
}
fclose(file_out);
///////
{
int count_center=0;
double C, C0;
gsl_vector* Q_real;
Q_initial=gsl_vector_calloc(Nt_2);
for(center=center_start; center<=center_stop; center+=center_delta)
{
double center_real=center/(2.0*dNt_2_pre);
double center_calculated=0.0;
double center_calculated_real=0.0;
char file_name[1000];
sprintf(file_name,"delta_function_c=%3.3leT.txt", center);
Q=gsl_vector_calloc(Nt_2);
Q_real=gsl_vector_calloc(Nt_2);
calculate_Q(Q, R, S, center_real);
if(count_center==0)
{
for(i=0;i<Nt_2;i++)
gsl_vector_set(Q_initial, i, gsl_vector_get(Q,i));
}
if(count_center==0)
{
for(i=0;i<Nt_2;i++)
gsl_vector_set(Q_real, i, gsl_vector_get(Q,i));
}
else
{
if(flag_exclude_delta==1 && count_center>=count_start_exclude)
{
FILE* log_exclusion;
log_exclusion=fopen_log("log_exclusion.txt","a", center_real);
C=delta0(Q);
C0=delta0(Q_initial);
fprintf(log_exclusion,"C=%.15le\nC0=%.15le\n",C,C0);fflush(log_exclusion);
for(i=0;i<Nt_2;i++)
gsl_vector_set(Q_real, i, gsl_vector_get(Q,i)-(C/C0)*gsl_vector_get(Q_initial,i));
//normalization
double new_norma=0.0;
for(i=0;i<Nt_2;i++)
{
new_norma += gsl_vector_get(Q_real, i) * gsl_vector_get(R,i);
}
fprintf(log_exclusion, "norma_old=%.15le\n", new_norma);fflush(log_exclusion);
for(i=0;i<Nt_2;i++)
{
gsl_vector_set(Q_real,i,gsl_vector_get(Q_real, i)/new_norma );
}
new_norma=0.0;
for(i=0;i<Nt_2;i++)
{
new_norma += gsl_vector_get(Q_real, i) * gsl_vector_get(R,i);
}
fprintf(log_exclusion, "norma_new=%.15le\n", new_norma);fflush(log_exclusion);
fclose(log_exclusion);
}
else
{
for(i=0;i<Nt_2;i++)
gsl_vector_set(Q_real, i, gsl_vector_get(Q,i));
}
}
//delta function output
file_out=fopen_control(file_name,"w");
for(omega=0;omega<omega_plot_limit/(2.0*dNt_2_pre);omega+=omega_plot_delta/(2.0*dNt_2_pre))
{
fprintf(file_out,"%.15le\t%.15le\t%.15le\n", omega*2.0*dNt_2_pre, delta(omega,Q), delta(omega, Q_real));
fflush(file_out);
}
fclose(file_out);
//output of dimensionless spectral function
double rho, rho_stat_err, width;
double rho_real, rho_stat_err_real, width_real;
//values to really characterize delta functions
double start, stop, center1, width1;
double real_start, real_stop, real_center1, real_width1;
file_out=fopen_control("rho.txt", "a");
file_out_excl=fopen_control("rho_excl.txt", "a");
calculate_rho(Q, current, error, &rho, &rho_stat_err);
width=delta_width_calculation(Q, center_real);
delta_characteristics_calculation(&start, &stop, ¢er1, Q, center_real);
width1=(stop-start)/2.0;
calculate_rho(Q_real, current, error, &rho_real, &rho_stat_err_real);
width_real=delta_width_calculation(Q_real, center_real);
delta_characteristics_calculation(&real_start, &real_stop, &real_center1, Q_real, center_real);
real_width1=(real_stop-real_start)/2.0;
fprintf(file_out,"%.15le\t%.15le\t%.15le\t%.15le\t%.15le\t%.15le\n", center, width*2.0*dNt_2_pre, center1, width1, rho, rho_stat_err);
fprintf(file_out_excl,"%.15le\t%.15le\t%.15le\t%.15le\t%.15le\t%.15le\n", center, width_real*2.0*dNt_2_pre, real_center1, real_width1, rho_real, rho_stat_err_real);
fclose(file_out);
fclose(file_out_excl);
gsl_vector_free(Q);
gsl_vector_free(Q_real);
count_center++;
}
gsl_vector_free(Q_initial);
}
gsl_vector_free(R);
gsl_vector_free(omega_R);
gsl_matrix_free(S);
gsl_matrix_free(S_pre);
free(current);
free(error);
free(current_pre);
free(error_pre);
if(flag_model==1)
free(points_numbers);
return 0;
}
