Beispiel #1
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 */
    outfile = fopen(MYFILE, "w");


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

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

    /* 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();

    /* Scan the delta plane */
    double this_delta;
    double delta_lower = -M_PI;
    double delta_upper = M_PI;
    double delta_steps = 72;
    double delta_step_size = (delta_upper-delta_lower)/delta_steps;
    double sig;
    printf("true delta_cp = %g \n", deltacp);
    for(this_delta=delta_lower; this_delta<=delta_upper; this_delta+= delta_step_size)
    {
        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(outfile, "%g %g\n", i, sig);
    }

    fclose(outfile);

    /* Destroy parameter and projection vector(s) */
    glbFreeParams(true_values);
    glbFreeParams(test_values);
    glbFreeParams(input_errors);

    outfile2 = fopen(MYFILE2, "w");
    dm31 = dm21-dm32;

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

    /* 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_delta=delta_lower; this_delta<=delta_upper; this_delta+= delta_step_size)
    {
        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(outfile2, "%g %g\n", i, sig);
    }

    fclose(outfile2);

    return 0;
}
Beispiel #2
0
void dcpvst23_mh(double osc[], double vrange[2])
{
  //Compute MH sensitivity as a function of deltaCP and t23
  //for input true values in osc, and over vrange in t23.
  double lowt23=vrange[0];
  double hight23=vrange[1];
  double steps=35;
  double minvars[4];
  double mindcp, mint23;

  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 minchi2=1e6, tminchi2=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,(M_PI/2)-thist23};
			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();
		
			//profile without systematics in deltacp, t23 octant
			tminchi2=1e6;
			mindcp=this_dcp;
			mint23=thist23;
			for(double this_tdcp=-M_PI;this_tdcp<M_PI;this_tdcp=this_tdcp+(M_PI/36)){
				for(int tk=0;tk<2;tk++){
					glbDefineParams(test_values,osc[0],osc[1],osc2[tk],this_tdcp,osc[4],-osc[5]+osc[4]);  
					glbSetDensityParams(test_values,1.0,GLB_ALL);
					double tchi2=glbChiSys(test_values,GLB_ALL,GLB_ALL);
					if(tchi2<tminchi2){
						tminchi2=tchi2;
						mindcp=this_tdcp;
						mint23=osc2[tk];
					}
				}
			}

			glbDefineParams(test_values,osc[0],osc[1],mint23,mindcp,osc[4],-osc[5]+osc[4]);  
			glbSetDensityParams(test_values,1.0,GLB_ALL);
			glbDefineParams(central_values,osc[0],osc[1],mint23,this_dcp,osc[4],-osc[5]+osc[4]);
			glbSetCentralValues(central_values);   
			if(arguments.test)
				minchi2=glbChiSys(test_values,GLB_ALL,GLB_ALL);
			else{
				minchi2=glbChiDelta(test_values,test_values,GLB_ALL);
			}
			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();
	}
}
Beispiel #3
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;
}