Exemple #1
0
void t13vst23(double osc[])
{
  //Compute region where  octant can be termined? in t13 and t23
  //for input true values in osc
  double chi2[2];
  double lowt23=osc[2];
  double hight23=M_PI/4;
  double lowt13=0;
  double hight13=osc[1];
  double tminchi2, tchi2;
  double mindcp[]={osc[3],osc[3]};
  double res;
  //set resolution
  if(arguments.tSteps==10){
    res=40;
  }else{
    res=arguments.tSteps;
  }  
  glb_projection projT23T13 = glbAllocProjection();
  glbDefineProjection(projT23T13, GLB_FREE, GLB_FIXED, GLB_FIXED, GLB_FIXED, GLB_FREE, GLB_FREE);
  glbSetDensityProjectionFlag(projT23T13, GLB_FREE, GLB_ALL);
  glbSetProjection(projT23T13);
  double osc5[]={osc[5],-osc[5]+osc[4]};
  
  for(double thist13=lowt13;thist13<=hight13;thist13+=(hight13-lowt13)/res){
    for(double thist23=lowt23;thist23<=hight23;thist23+=(hight23-lowt23)/res){
			glbDefineParams(true_values,osc[0],thist13,thist23,osc[3],osc[4],osc[5]);
			glbSetDensityParams(true_values,1.0,GLB_ALL);
			glbSetOscillationParameters(true_values);
			glbSetRates();
			
			//prescan without systematics in deltacp, t23 octant
			for(int tk=0;tk<2;tk++){
				tminchi2=1e6;
				for(double this_tdcp=-M_PI;this_tdcp<M_PI;this_tdcp=this_tdcp+(M_PI/36)){
					glbDefineParams(test_values,osc[0],thist13,(M_PI/2)-thist23,this_tdcp,osc[4],osc5[tk]);  
					glbSetDensityParams(test_values,1.0,GLB_ALL);
					tchi2=glbChiSys(test_values,GLB_ALL,GLB_ALL);
					if(tchi2<tminchi2){
						tminchi2=tchi2;
						mindcp[tk]=this_tdcp;
					}
				}
			}
			for(int k=0;k<2;k++){ //profile over MH
				glbDefineParams(test_values,osc[0],thist13,(M_PI/2)-thist23,mindcp[k],osc[4],osc5[k]);  
				glbSetDensityParams(test_values,1.0,GLB_ALL);
				glbDefineParams(central_values,osc[0],thist13,thist23,osc[3],osc[4],osc5[k]);
				glbSetCentralValues(central_values);  
				if(arguments.test)
					chi2[k]=glbChiSys(test_values,GLB_ALL,GLB_ALL);
				else
					chi2[k]=glbChiNP(test_values,test_values,GLB_ALL);
			}
			double a[]={thist13,thist23, chi2[0], chi2[1]};
			AddArrayToOutput(a,4);
		}
	AddToOutputBlankline();
  }
}
Exemple #2
0
void dcpvst23_cpv(double osc[], double vrange[2])
{
  //Compute CPV sensitivity as a function of deltaCP and t23
  //for input true values in osc, and over vrange in t23.
  double chi2[8];
  double minvars[4]={0,0,0,0};
  double lowt23=vrange[0];
  double hight23=vrange[1];
  double steps=35;
  
  glb_projection proj= glbAllocProjection();
  //keeping t12 and DM21 fixed to speed things up
  glbDefineProjection(proj, GLB_FIXED, GLB_FREE, GLB_FREE, GLB_FIXED, GLB_FIXED, GLB_FREE);
  glbSetDensityProjectionFlag(proj, GLB_FIXED, GLB_ALL);
  glbSetProjection(proj);
  
  glbDefineParams(true_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc[5]);
  glbSetDensityParams(true_values,1.0,GLB_ALL);
  glbSetOscillationParameters(true_values);
  glbSetRates();
	double osc3[]={0,M_PI,0,M_PI,0,M_PI,0,M_PI};
	double osc5[]={osc[5],osc[5],-osc[5]+osc[4],-osc[5]+osc[4],osc[5],osc[5],-osc[5]+osc[4],-osc[5]+osc[4]};
	double minchi2=1e6;
  for(double this_dcp=-M_PI;this_dcp<=M_PI;this_dcp=this_dcp+(M_PI/steps)){
    for(double thist23=lowt23;thist23<=hight23;thist23+=(hight23-lowt23)/steps){	
			double osc2[] = {thist23,thist23,thist23,thist23,(M_PI/2)-thist23,(M_PI/2)-thist23,(M_PI/2)-thist23,(M_PI/2)-thist23};
			minchi2=1e6;
			for(int k=0;k<8;k++){ //profile octant, deltaCP=0,PI, and MH
				glbDefineParams(true_values,osc[0],osc[1],thist23,this_dcp,osc[4],osc[5]);
				glbSetDensityParams(true_values,1.0,GLB_ALL);
				glbSetOscillationParameters(true_values);
				glbSetRates();
			
				glbDefineParams(test_values,osc[0],osc[1],osc2[k],osc3[k],osc[4],osc5[k]);
				glbSetDensityParams(test_values,1.0,GLB_ALL);
				//set central values to match test_values
				glbDefineParams(central_values,osc[0],osc[1],osc2[k],osc3[k],osc[4],osc5[k]);
				glbSetCentralValues(central_values); 
			  
				if(arguments.test)
					chi2[k]=glbChiSys(test_values,GLB_ALL,GLB_ALL);
				else
					chi2[k]=glbChiNP(test_values,test_values,GLB_ALL);
					
				if(chi2[k]<minchi2){
					minchi2=chi2[k];
					minvars[0]=glbGetOscParams(test_values,GLB_THETA_13);
					minvars[1]=glbGetOscParams(test_values,GLB_THETA_23);
					minvars[2]=glbGetOscParams(test_values,GLB_DELTA_CP);
					minvars[3]=glbGetOscParams(test_values,GLB_DM_31);
				}
			}
						
			double a[]={this_dcp,thist23, minchi2, minvars[0], minvars[1], minvars[2], minvars[3]};
			AddArrayToOutput(a,7);
		}
	AddToOutputBlankline();
  }
}
Exemple #3
0
void t13vst23_AR(double osc[])
{
  //Compute actual allowed regions in t13 and t23
  //for input true values in osc
  double chi2[2];
  double lowt23=0.3;//osc[2];
  double hight23=1.0;//M_PI/4;
  double lowt13=0;
  double hight13=0.2318;
  double res;
  //set resolution
  if(arguments.tSteps==10){
    res=40;
  }else{
    res=arguments.tSteps;
  }  
  //setup projection into t23 and t13 plane
  glb_projection projT23T13 = glbAllocProjection();
  glbDefineProjection(projT23T13, GLB_FREE, GLB_FIXED, GLB_FIXED, GLB_FREE, GLB_FREE, GLB_FREE);
  glbSetDensityProjectionFlag(projT23T13, GLB_FREE, GLB_ALL);
  glbSetProjection(projT23T13);
  
  //set true values and rates
  glbDefineParams(true_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc[5]);
  glbSetDensityParams(true_values,1.0,GLB_ALL);
  glbSetOscillationParameters(true_values);
  glbSetRates();

  double osc5[]={osc[5],-osc[5]+osc[4]};
  
  for(double thist13=lowt13;thist13<=hight13;thist13+=(hight13-lowt13)/res){
    for(double thist23=lowt23;thist23<=hight23;thist23+=(hight23-lowt23)/res){
			for(int k=0;k<2;k++){ //about chisq for both MHs
				glbDefineParams(test_values,osc[0],thist13,thist23,osc[3],osc[4],osc5[k]);  
				glbSetDensityParams(test_values,1.0,GLB_ALL);
				//glbDefineParams(central_values,osc[0],thist13,thist23,osc[3],osc[4],osc5[k]);
        //glbDefineParams(central_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc5[k]);
				//glbSetCentralValues(central_values);  
				if(arguments.test)
					chi2[k]=glbChiSys(test_values,GLB_ALL,GLB_ALL);
				else
					chi2[k]=glbChiNP(test_values,test_values,GLB_ALL);
			}
			double a[]={thist13,thist23, chi2[0], chi2[1]};
			AddArrayToOutput(a,4);
		}
	AddToOutputBlankline();
  }
}
Exemple #4
0
void dm31vst23(double osc[], double vrange[2])
{
  //Compute allowed regions in DM31 and t23
  //for input true values in osc, and over vrange in t23.
  double chi2[2];
  double lowt23=vrange[0];
  double hight23=vrange[1];
  double lowdm31=2.1e-3;
  double highdm31=2.9e-3;
  double res;
  //set resolution
  if(arguments.tSteps==10){
    res=40;
  }else{
    res=arguments.tSteps;
  }  
  glb_projection projT23dm31 = glbAllocProjection();
  glbDefineProjection(projT23dm31, GLB_FREE, GLB_FREE, GLB_FIXED, GLB_FREE, GLB_FREE, GLB_FIXED);
  glbSetDensityProjectionFlag(projT23dm31, GLB_FREE, GLB_ALL);
  glbSetProjection(projT23dm31);
  
  glbDefineParams(true_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc[5]);
  glbSetDensityParams(true_values,1.0,GLB_ALL);
  glbSetOscillationParameters(true_values);
  glbSetRates();
	
  for(double thisdm31=lowdm31;thisdm31<highdm31;thisdm31+=(highdm31-lowdm31)/res){
    for(double thist23=lowt23;thist23<=hight23;thist23+=(hight23-lowt23)/res){
			double osc5[]={thisdm31,-thisdm31+osc[4]};
			for(int k=0;k<2;k++){ //profile MH
				glbDefineParams(test_values,osc[0],osc[1],thist23,osc[3],osc[4],osc5[k]);
				glbSetDensityParams(test_values,1.0,GLB_ALL); 
				glbDefineParams(central_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc5[k]);
				glbSetCentralValues(central_values);  
				if(arguments.test)
					chi2[k]=glbChiSys(test_values,GLB_ALL,GLB_ALL);
				else
					chi2[k]=glbChiNP(test_values,test_values,GLB_ALL);
			}
			
			double a[]={thisdm31,thist23, chi2[0], chi2[1]};
			AddArrayToOutput(a,4);
		}
	AddToOutputBlankline();
  }
}
Exemple #5
0
void dcpvst23(double osc[], double vrange[2])
{
  //Compute allowed regions in DeltaCP vs t23 for true values in osc over range vrange in t23
  double chi2[2];
  double lowt23=vrange[0];
  double hight23=vrange[1];
  double res;
  //set resolution
  if(arguments.tSteps==10){
    res=40;
  }else{
    res=arguments.tSteps;
  }  
  glb_projection projT23dcp = glbAllocProjection();
  glbDefineProjection(projT23dcp, GLB_FREE, GLB_FREE, GLB_FIXED, GLB_FIXED, GLB_FREE, GLB_FREE);
  glbSetDensityProjectionFlag(projT23dcp, GLB_FREE, GLB_ALL);
  glbSetProjection(projT23dcp);
  
  glbDefineParams(true_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc[5]);
  glbSetDensityParams(true_values,1.0,GLB_ALL);
  glbSetOscillationParameters(true_values);
  glbSetRates();
	double osc5[]={osc[5],-osc[5]+osc[4]};
	
  for(double this_dcp=-M_PI;this_dcp<=M_PI;this_dcp=this_dcp+(M_PI/res)){
    for(double thist23=lowt23;thist23<=hight23;thist23+=(hight23-lowt23)/res){
			for(int k=0;k<2;k++){ //profile MH
				glbDefineParams(test_values,osc[0],osc[1],thist23,this_dcp,osc[4],osc5[k]);  
				glbSetDensityParams(test_values,1.0,GLB_ALL);
				glbDefineParams(central_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc5[k]);
				glbSetCentralValues(central_values); 
				if(arguments.test)
					chi2[k]=glbChiSys(test_values,GLB_ALL,GLB_ALL);
				else
					chi2[k]=glbChiNP(test_values,test_values,GLB_ALL);
			}
			double a[]={this_dcp,thist23, chi2[0], chi2[1]};
			AddArrayToOutput(a,4);
		}
	AddToOutputBlankline();
  }
}
Exemple #6
0
void dcpvst23_nmq(double osc[], double vrange[2])
{
  //Compute deltachisq for non-maximal t23 sensitivity as a function of deltaCP and t23
  //for input true values in osc, and over vrange in t23.
  double chi2[2];
  double minvars[2][4];
  double lowt23=vrange[0];
  double hight23=vrange[1];
	double tminchi2, tchi2;
  double steps=35; //note that both axes use double this number of steps
  double mindcp=osc[3];
  
  glb_projection proj= glbAllocProjection();
  //keeping t12 and DM21 fixed to speed things up
  glbDefineProjection(proj, GLB_FIXED, GLB_FREE, GLB_FIXED, GLB_FREE, GLB_FIXED, GLB_FREE);
  glbSetDensityProjectionFlag(proj, GLB_FIXED, GLB_ALL);
  glbSetProjection(proj);
  
  glbDefineParams(true_values,osc[0],osc[1],osc[2],osc[3],osc[4],osc[5]);
  glbSetDensityParams(true_values,1.0,GLB_ALL);
  glbSetOscillationParameters(true_values);
  glbSetRates();
	double osc5[]={osc[5],-osc[5]+osc[4]};
  for(double this_dcp=-M_PI;this_dcp<=M_PI;this_dcp=this_dcp+(M_PI/steps)){
    for(double thist23=lowt23;thist23<=hight23;thist23+=(hight23-lowt23)/(2*steps)){	
			for(int k=0;k<2;k++){ //profile MH
				glbDefineParams(true_values,osc[0],osc[1],thist23,this_dcp,osc[4],osc[5]);
				glbSetDensityParams(true_values,1.0,GLB_ALL);
				glbSetOscillationParameters(true_values);
				glbSetRates();
				
				//do prescan without systematics in deltacp, t23 octant
				tminchi2=1e6;
				for(double this_tdcp=-M_PI;this_tdcp<M_PI;this_tdcp=this_tdcp+(M_PI/36)){
					glbDefineParams(test_values,osc[0],osc[1],(M_PI/4),this_tdcp,osc[4],osc5[k]);  
					glbSetDensityParams(test_values,1.0,GLB_ALL);
					tchi2=glbChiSys(test_values,GLB_ALL,GLB_ALL);
					if(tchi2<tminchi2){
						tminchi2=tchi2;
						mindcp=this_tdcp;
					}
				}
				
				glbDefineParams(test_values,osc[0],osc[1],(M_PI/4),mindcp,osc[4],osc5[k]);
				glbSetDensityParams(test_values,1.0,GLB_ALL);
				glbDefineParams(central_values,osc[0],osc[1],(M_PI/4),this_dcp,osc[4],osc5[k]);
				glbSetCentralValues(central_values); 
				if(arguments.test)
					chi2[k]=glbChiSys(test_values,GLB_ALL,GLB_ALL);
				else
					chi2[k]=glbChiNP(test_values,test_values,GLB_ALL);
					
				minvars[k][0]=glbGetOscParams(test_values,GLB_THETA_13);
				minvars[k][1]=glbGetOscParams(test_values,GLB_THETA_23);
				minvars[k][2]=glbGetOscParams(test_values,GLB_DELTA_CP);
				minvars[k][3]=glbGetOscParams(test_values,GLB_DM_31);
			}
			double minchi2=1e6; int mini=0;
			for(int i=0;i<2;i++) if(chi2[i]<minchi2) {minchi2=chi2[i]; mini=i;}
			double a[]={this_dcp,thist23, minchi2, minvars[mini][0], minvars[mini][1], minvars[mini][2], minvars[mini][3]};
			AddArrayToOutput(a,7);
		}
	AddToOutputBlankline();
  }
}
Exemple #7
0
int main(int argc, char *argv[])
{ 
  double thetheta13, x, y, res;
  
  /* Define standard oscillation parameters (cf. hep-ph/0405172v5) */
  double true_theta12 = asin(sqrt(0.3));
  double true_theta13 = 0.0;
  double true_theta23 = M_PI/4;
  double true_deltacp = 0.0;
  double true_sdm = 7.9e-5;
  double true_ldm = 2.6e-3;

  /* Define one non-standard parameter sigma_E (wave packet energy spread
   * responsible for wave packet decoherence) */
  double true_sigma_E = 0.0;

  /* Initialize libglobes */
  glbInit(argv[0]);
 
  /* Register non-standard probability engine. This has to be done
   * before any calls to glbAllocParams() or glbAllocProjections() */
  glbRegisterProbabilityEngine(7,      /* Number of parameters */
                               &my_probability_matrix,
                               &my_set_oscillation_parameters,
                               &my_get_oscillation_parameters,
                               NULL);

  /* Initialize reactor experiment */
  glbInitExperiment("Reactor1.glb",&glb_experiment_list[0],&glb_num_of_exps); 
 
  /* Initialize parameter and projection vector(s) */
  glb_params true_values = glbAllocParams();
  glb_params test_values = glbAllocParams();
  glb_params input_errors = glbAllocParams();
  glb_projection th13_sigma_projection = glbAllocProjection();  

  glbDefineParams(true_values,true_theta12,true_theta13,true_theta23,
                              true_deltacp,true_sdm,true_ldm);
  glbSetOscParams(true_values,true_sigma_E, GLB_SIGMA_E);   /* Non-standard parameter */
  glbSetDensityParams(true_values,1.0,GLB_ALL);
  glbDefineParams(test_values,true_theta12,true_theta13,true_theta23,
                              true_deltacp,true_sdm,true_ldm);
  glbSetOscParams(test_values,true_sigma_E, GLB_SIGMA_E);   /* Non-standard parameter */
  glbSetDensityParams(test_values,1.0,GLB_ALL);

  /* The simulated data are computed */
  glbSetOscillationParameters(true_values);
  glbSetRates();

  /* Set starting values and input errors for all projections */  
  glbDefineParams(input_errors, 0.1*true_theta12, 0.0, 0.15*true_theta23,
                                0.0, 0.05*true_sdm, 0.05*true_ldm);  
  glbSetOscParams(input_errors, 0.0, GLB_SIGMA_E);      /* Non-standard parameter */
  glbSetDensityParams(input_errors, 0.05, GLB_ALL);
  glbSetCentralValues(true_values);
  glbSetInputErrors(input_errors);

  /* Compute chi^2 without correlations */

  FILE *fp=fopen("osc-data1","w");
 
  for(x=0; x < 0.05+0.001; x+=0.005)        /* th13 loop */
    {
      for(y=0.0; y < 0.010+0.001; y+=0.001)   /* sigame_E loop */
	{
	  /* Set vector of test=fit values */
	  thetheta13=asin(sqrt(x))/2.0;
	  glbSetOscParams(test_values,thetheta13,GLB_THETA_13);
	  glbSetOscParams(test_values,y,GLB_SIGMA_E);
	  
	  /* Compute Chi^2 with systematics only */
	  res=glbChiSys(test_values,GLB_ALL,GLB_ALL);
	  fprintf(fp,"%f\t%f\t%f\n",x,y,res);
      
	}
      fprintf(fp,"\n");
    }
  
  fclose(fp);

  fp=fopen("osc-data2","w");
  
  /* Set two-parameter projection onto s22th13 and sigma_E, marginalizing
   * over all other parameters except delta_CP and th23, which do not enter P_ee */
  glbDefineProjection(th13_sigma_projection, GLB_FREE, GLB_FIXED, GLB_FIXED,
		      GLB_FIXED, GLB_FREE, GLB_FREE);
  glbSetDensityProjectionFlag(th13_sigma_projection, GLB_FIXED, GLB_ALL);
  glbSetProjectionFlag(th13_sigma_projection, GLB_FIXED, GLB_SIGMA_E); /* Non-standard parameter */
  glbSetProjection(th13_sigma_projection); 
  
  for(x=0; x < 0.05+0.001; x+=0.005)        /* th13 loop */
    {   
      for(y=0.0; y < 0.010+0.001; y+=0.001)   /* sigame_E loop */
	{
	  /* Set vector of test=fit values */
	  thetheta13=asin(sqrt(x))/2.0;
	  glbSetOscParams(test_values,thetheta13,GLB_THETA_13);
	  glbSetOscParams(test_values,y,GLB_SIGMA_E);
	  
	  /* Compute Chi^2 with correlations */
	  res=glbChiNP(test_values,NULL,GLB_ALL);
	  fprintf(fp,"%f\t%f\t%f\n",x,y,res);
	  
	}
      fprintf(fp,"\n");
    }
  fclose(fp);
  
  /* Destroy parameter and projection vector(s) */
  glbFreeParams(true_values);
  glbFreeParams(test_values); 
  glbFreeParams(input_errors); 
  glbFreeProjection(th13_sigma_projection);
    
  exit(0);
}
Exemple #8
0
int main(int argc, char *argv[])
{ 
  /* Initialize libglobes */
  glbInit(argv[0]);

  /* Initialize experiment */
  //glbInitExperiment(AEDLFILE,&glb_experiment_list[0],&glb_num_of_exps); 
  glbInitExperiment(AEDLFILE2,&glb_experiment_list[0],&glb_num_of_exps); /* nuPRISM */
  //glbInitExperiment(AEDLFILE3,&glb_experiment_list[0],&glb_num_of_exps); /* Reactor */

  /* Intitialize output */
  outfile1 = fopen(MYFILE1, "w");
  outfile2 = fopen(MYFILE2, "w");
  outfile3 = fopen(MYFILE3, "w");
  outfile4 = fopen(MYFILE4, "w");
  outfile5 = fopen(MYFILE5, "w");
  outfile6 = fopen(MYFILE6, "w");
  outfile7 = fopen(MYFILE7, "w");

  /* Define "true" oscillation parameters */
  theta12 = asin(sqrt(0.307));
  theta13 = asin(sqrt(0.0241));
  theta23 = 0.5;
  deltacp = 0.0;
  dm21 = 7.6e-5;
  dm32 = 2.4e-3;
  dm31 = dm32 + dm21;

  /* Needed for scans */
  double e_min = 0.0;
  double e_max = 3.0;
  double dist = 295.0;
  double E = 0.0;
  int bins = glbGetNumberOfBins(0);
  int polar = +1;
  int n_bins = 100;
  int bin;
  double e_step = (e_max-e_min)/(n_bins);
  double this_th13, this_delta;
  double th13_lower  = asin(sqrt(0.01));
  double th13_upper  = asin(sqrt(0.04));
  double th13_steps  = 15;
  double delta_lower = -M_PI;
  double delta_upper = M_PI;
  double delta_steps = 15;
  double res, sig, flux;


  true_values = glbAllocParams();
  test_values = glbAllocParams();
  input_errors = glbAllocParams();
  th13delta_projection = glbAllocProjection();

  glbDefineProjection(th13delta_projection,GLB_FIXED,GLB_FIXED,GLB_FREE,GLB_FIXED,GLB_FIXED,GLB_FREE);
  glbSetDensityProjectionFlag(th13delta_projection, GLB_FIXED, GLB_ALL);
  glbSetProjection(th13delta_projection);

  glbDefineParams(true_values,theta12,theta13,theta23,deltacp,dm21,dm31);
  glbSetDensityParams(true_values,1.0,GLB_ALL);

  glbSetOscillationParameters(true_values);
  glbSetRates();

  /*------------------------------------- Initial Fluxes ---------------------------------------------------*/

  printf("Initial fluxes \n");

  for(E = e_min; E<e_max; E += e_step){
    flux = glbFlux(0, 0, E, dist, 1, polar);
    fprintf(outfile1, "%g %g \n", E, flux);
  }

  for(E = e_min; E<e_max; E += e_step){
    flux = glbFlux(0, 0, E, dist, 2, polar);
    fprintf(outfile2, "%g %g \n", E, flux);
  }

  fclose(outfile1);
  fclose(outfile2);

  /*---------------------------------------- Event Rates ---------------------------------------------------*/

  printf("Event Rates \n");

  // rule 0 = NU_E_Appearance_QE
  // rule 2 = NU_MU_Disappearance_QE
  // rule 4 = NU_MU_Disappearance_CC
  // rule 5 = NU_E_Appearance_CC

  double *rates_e = glbGetRuleRatePtr(0,5);
  double *rates_mu = glbGetRuleRatePtr(0,4);

  for(bin=0;bin<bins;bin++){
    fprintf(outfile3, "%i %g \n", bin, rates_e[bin]);
    fprintf(outfile4, "%i %g \n", bin, rates_mu[bin]);
  }

  fclose(outfile3);
  fclose(outfile4);

  /*------------------------------------- Delta CP Significance ----------------------------------------------*/

  printf("Delta_cp significance \n");
  delta_steps = 40;
  glbDefineParams(test_values,theta12,theta13,theta23,deltacp,dm21,dm31);  
  glbSetDensityParams(test_values,1.0,GLB_ALL);
  glbDefineParams(input_errors, theta12*0.1, 0, 0, 0, dm21*0.1, 0);
  glbSetDensityParams(input_errors,0.05,GLB_ALL);
  glbSetInputErrors(input_errors);
  glbSetCentralValues(true_values);

  for(this_delta=delta_lower; this_delta<=delta_upper; this_delta+= (delta_upper-delta_lower)/delta_steps)
    {
      double x = sin(this_delta);
      double i = this_delta*180.0/M_PI;
      glbSetOscParams(test_values, asin(x), GLB_DELTA_CP);
      double chi2=glbChiDelta(test_values, NULL, GLB_ALL);
      glbSetOscParams(test_values, deltacp, GLB_DELTA_CP);
      double chitrue=glbChiDelta(test_values, NULL, GLB_ALL);
      sig = sqrt(abs(chi2 - chitrue));
      printf("delta = %g \n", i);
      fprintf(outfile5, "%g %g\n", i, sig);
    }

  fclose(outfile5);


  /*------------------------------------- theta13 - delta_cp scan ---------------------------------------------------*/

  delta_steps = 15;
  printf("Initial th13-deltacp scan \n");

  for(deltacp = -M_PI/2.0; deltacp < M_PI+0.1; deltacp += M_PI/2.0){
    double x = deltacp/M_PI;
    printf("Delta_CP = %g\n", x);

    /* Define "true" oscillation parameter vector */
    glbDefineParams(true_values,theta12,theta13,theta23,deltacp,dm21,dm31);
    glbSetDensityParams(true_values,1.0,GLB_ALL);
 
    /* Define initial guess for the fit values */ 
    glbDefineParams(test_values,theta12,theta13,theta23,deltacp,dm21,dm31);  
    glbSetDensityParams(test_values,1.0,GLB_ALL);

    glbDefineParams(input_errors, theta12*0.1, 0, 0, 0, dm21*0.1, 0);
    glbSetDensityParams(input_errors,0.05,GLB_ALL);
    glbSetInputErrors(input_errors);
    glbSetCentralValues(true_values);

    /* Compute simulated data */
    glbSetOscillationParameters(true_values);
    glbSetRates();

    for(this_th13=th13_lower; this_th13<=th13_upper; this_th13+=(th13_upper-th13_lower)/th13_steps)
      {
	for(this_delta=delta_lower; this_delta<=delta_upper; this_delta+=(delta_upper-delta_lower)/delta_steps)
	  {
	    glbSetOscParams(test_values, this_th13, GLB_THETA_13);
	    glbSetOscParams(test_values, this_delta, GLB_DELTA_CP);
	    double i = sin(2*this_th13)*sin(2*this_th13);
	    double j = this_delta*180.0/M_PI;
	    res=glbChiNP(test_values, NULL, GLB_ALL);
	    fprintf(outfile6, "%g %g %g\n", i, j, res);
	  }
	fprintf(outfile6, "\n");
      }
  }

  fclose(outfile6);

  /*------------------------------------- theta13 - delta_cp scan - Half errors -------------------------------------*/

  printf("th13-deltacp scan with half the errors \n");

  HalfErrors();
  delta_steps = 60;
  th13_steps = 60;

  for(deltacp = -M_PI/2.0; deltacp < M_PI+0.1; deltacp += M_PI/2.0){
    double x = deltacp/M_PI;
    printf("Delta_CP = %g\n", x);

    /* Define "true" oscillation parameter vector */
    glbDefineParams(true_values,theta12,theta13,theta23,deltacp,dm21,dm31);
    glbSetDensityParams(true_values,1.0,GLB_ALL);
 
    /* Define initial guess for the fit values */ 
    glbDefineParams(test_values,theta12,theta13,theta23,deltacp,dm21,dm31);  
    glbSetDensityParams(test_values,1.0,GLB_ALL);

    glbDefineParams(input_errors, theta12*0.1, 0, 0, 0, dm21*0.1, 0);
    glbSetDensityParams(input_errors,0.05,GLB_ALL);
    glbSetInputErrors(input_errors);
    glbSetCentralValues(true_values);

    /* Compute simulated data */
    glbSetOscillationParameters(true_values);
    glbSetRates();

    for(this_th13=th13_lower; this_th13<=th13_upper; this_th13+=(th13_upper-th13_lower)/th13_steps)
      {
	for(this_delta=delta_lower; this_delta<=delta_upper; this_delta+=(delta_upper-delta_lower)/delta_steps)
	  {
	    glbSetOscParams(test_values, this_th13, GLB_THETA_13);
	    glbSetOscParams(test_values, this_delta, GLB_DELTA_CP);
	    double i = sin(2*this_th13)*sin(2*this_th13);
	    double j = this_delta*180.0/M_PI;
	    double res=glbChiNP(test_values, NULL, GLB_ALL);
	    fprintf(outfile7, "%g %g %g\n", i, j, res);
	  }
	fprintf(outfile7, "\n");
      }
  }
  fclose(outfile7);

  glbFreeParams(test_values);
  glbFreeParams(input_errors);
  glbFreeProjection(th13delta_projection);
  glbFreeParams(true_values);
  return 0;
}