#include <TGraphErrors.h>
#include <TGraph.h>
#include <TCanvas.h>
#include <TLegend.h>
#include <Rtypes.h>

void dokimi() {


TFile *file = new TFile("the_differents_histograms.root", "READ");
	
TH2F *resultHistogramA01 = (TH2F*)file->Get("h_A_phi01_PCB_Layer");
TH2F *resultHistogramA02 = (TH2F*)file->Get("h_A_phi02_PCB_Layer");
TH2F *resultHistogramA03 = (TH2F*)file->Get("h_A_phi03_PCB_Layer");
TH2F *resultHistogramA04 = (TH2F*)file->Get("h_A_phi04_PCB_Layer");
TH2F *resultHistogramA05 = (TH2F*)file->Get("h_A_phi05_PCB_Layer");
TH2F *resultHistogramA06 = (TH2F*)file->Get("h_A_phi06_PCB_Layer");
TH2F *resultHistogramA07 = (TH2F*)file->Get("h_A_phi07_PCB_Layer");
TH2F *resultHistogramA08 = (TH2F*)file->Get("h_A_phi08_PCB_Layer");
TH2F *resultHistogramA09 = (TH2F*)file->Get("h_A_phi09_PCB_Layer");
TH2F *resultHistogramA10 = (TH2F*)file->Get("h_A_phi10_PCB_Layer");
TH2F *resultHistogramA11 = (TH2F*)file->Get("h_A_phi11_PCB_Layer");
TH2F *resultHistogramA12 = (TH2F*)file->Get("h_A_phi12_PCB_Layer");
TH2F *resultHistogramA13 = (TH2F*)file->Get("h_A_phi13_PCB_Layer");
TH2F *resultHistogramA14 = (TH2F*)file->Get("h_A_phi14_PCB_Layer");
TH2F *resultHistogramA15 = (TH2F*)file->Get("h_A_phi15_PCB_Layer");
TH2F *resultHistogramA16 = (TH2F*)file->Get("h_A_phi16_PCB_Layer");

TH2F *resultHistogramC01 = (TH2F*)file->Get("h_C_phi01_PCB_Layer");
TH2F *resultHistogramC02 = (TH2F*)file->Get("h_C_phi02_PCB_Layer");
TH2F *resultHistogramC03 = (TH2F*)file->Get("h_C_phi03_PCB_Layer");
TH2F *resultHistogramC04 = (TH2F*)file->Get("h_C_phi04_PCB_Layer");
TH2F *resultHistogramC05 = (TH2F*)file->Get("h_C_phi05_PCB_Layer");
TH2F *resultHistogramC06 = (TH2F*)file->Get("h_C_phi06_PCB_Layer");
TH2F *resultHistogramC07 = (TH2F*)file->Get("h_C_phi07_PCB_Layer");
TH2F *resultHistogramC08 = (TH2F*)file->Get("h_C_phi08_PCB_Layer");
TH2F *resultHistogramC09 = (TH2F*)file->Get("h_C_phi09_PCB_Layer");
TH2F *resultHistogramC10 = (TH2F*)file->Get("h_C_phi10_PCB_Layer");
TH2F *resultHistogramC11 = (TH2F*)file->Get("h_C_phi11_PCB_Layer");
TH2F *resultHistogramC12 = (TH2F*)file->Get("h_C_phi12_PCB_Layer");
TH2F *resultHistogramC13 = (TH2F*)file->Get("h_C_phi13_PCB_Layer");
TH2F *resultHistogramC14 = (TH2F*)file->Get("h_C_phi14_PCB_Layer");
TH2F *resultHistogramC15 = (TH2F*)file->Get("h_C_phi15_PCB_Layer");
TH2F *resultHistogramC16 = (TH2F*)file->Get("h_C_phi16_PCB_Layer");


double Multiplicity[17][9]; // (sector, pcb)
double Multiplicity_C[17][9];


//initialize
for (int PCB = 0; PCB < 9; PCB++) {
	for (int sector = 0; sector < 17; sector++) {
		Multiplicity[sector][PCB] = 0.;
		Multiplicity_C[sector][PCB] = 0.;
	}
}

////////////

for (int PCB = 1; PCB <= resultHistogramA01->GetNbinsX(); PCB++) {
    double multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA01->GetNbinsY(); biny++) {
        double content = resultHistogramA01->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[1][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA02->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA02->GetNbinsY(); biny++) {
        double content = resultHistogramA02->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[2][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA03->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA03->GetNbinsY(); biny++) {
        double content = resultHistogramA03->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[3][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA04->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA04->GetNbinsY(); biny++) {
        double content = resultHistogramA04->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[4][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA05->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA05->GetNbinsY(); biny++) {
        double content = resultHistogramA05->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[5][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA06->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA06->GetNbinsY(); biny++) {
        double content = resultHistogramA06->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[6][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA07->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA07->GetNbinsY(); biny++) {
        double content = resultHistogramA07->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[7][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA08->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA08->GetNbinsY(); biny++) {
        double content = resultHistogramA08->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[8][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA09->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA09->GetNbinsY(); biny++) {
        double content = resultHistogramA09->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[9][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA10->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA10->GetNbinsY(); biny++) {
        double content = resultHistogramA10->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[10][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA11->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA11->GetNbinsY(); biny++) {
        double content = resultHistogramA11->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[11][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA12->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA12->GetNbinsY(); biny++) {
        double content = resultHistogramA12->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[12][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA13->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA13->GetNbinsY(); biny++) {
        double content = resultHistogramA13->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[13][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA14->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA14->GetNbinsY(); biny++) {
        double content = resultHistogramA14->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[14][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA15->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA15->GetNbinsY(); biny++) {
        double content = resultHistogramA15->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[15][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramA16->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramA16->GetNbinsY(); biny++) {
        int content = resultHistogramA16->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity[16][PCB] = multiplicity;
}

// Now, let's do the same for "C" histograms

for (int PCB = 1; PCB <= resultHistogramC01->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC01->GetNbinsY(); biny++) {
        int content = resultHistogramC01->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[1][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC02->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC02->GetNbinsY(); biny++) {
        double content = resultHistogramC02->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[2][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC03->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC03->GetNbinsY(); biny++) {
        double content = resultHistogramC03->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[3][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC04->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC04->GetNbinsY(); biny++) {
        double content = resultHistogramC04->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[4][PCB] = multiplicity;
}


for (int PCB = 1; PCB <= resultHistogramC05->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC05->GetNbinsY(); biny++) {
        double content = resultHistogramC05->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[5][PCB] = multiplicity;
}




for (int PCB = 1; PCB <= resultHistogramC06->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC06->GetNbinsY(); biny++) {
        double content = resultHistogramC06->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[6][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC07->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC07->GetNbinsY(); biny++) {
        double content = resultHistogramC07->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[7][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC08->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC08->GetNbinsY(); biny++) {
        double content = resultHistogramC08->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[8][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC09->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC09->GetNbinsY(); biny++) {
        double content = resultHistogramC09->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[9][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC10->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC10->GetNbinsY(); biny++) {
        double content = resultHistogramC10->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[10][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC11->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC11->GetNbinsY(); biny++) {
        double content = resultHistogramC11->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[11][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC12->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC12->GetNbinsY(); biny++) {
        double content = resultHistogramC12->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[12][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC13->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC13->GetNbinsY(); biny++) {
        double content = resultHistogramC13->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[13][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC14->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC14->GetNbinsY(); biny++) {
        double content = resultHistogramC14->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[14][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC15->GetNbinsX(); PCB++) {
    int multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC15->GetNbinsY(); biny++) {
        double content = resultHistogramC15->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[15][PCB] = multiplicity;
}

for (int PCB = 1; PCB <= resultHistogramC16->GetNbinsX(); PCB++) {
    double multiplicity = 0;
    for (int biny = 1; biny <= resultHistogramC16->GetNbinsY(); biny++) {
        double content = resultHistogramC16->GetBinContent(PCB, biny);
        multiplicity += content;
    }
    // Assign the multiplicity to the corresponding element in the matrix
    Multiplicity_C[16][PCB] = multiplicity;
}




/*
for (int PCB = 1; PCB <9 ; PCB++) {
	for (int sector = 1; sector <17 ; sector++){
    cout << "\nMultiplicity at(" << PCB <<"," <<sector<<") = " << Multiplicity[sector][PCB] << endl;
	}
}

*/

cout <<"\n\n\n\n\n\n\n";
/////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////       Multiplicity       ////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////



double Average_L_A[9] = {0.0};
double Average_S_A[9] = {0.0};
double Average_L_C[9] = {0.0};
double Average_S_C[9] = {0.0};
double Error_L_A[9] = {0.0};
double Error_S_A[9] = {0.0};
double Error_L_C[9] = {0.0};
double Error_S_C[9] = {0.0};


/////////////////  average
for (int PCB = 1; PCB < 9; PCB++){
	for (int sector = 1; sector < 17; sector++){	
		
		int p = sector / 2;
        	if (sector - 2 * p != 0){
        		//cout <<"Large Sector "<<sector<<endl;
        		Average_L_A[PCB]+= (Multiplicity[sector][PCB])/8.;
        		Average_L_C[PCB]+= (Multiplicity_C[sector][PCB])/8.;
        	}
		else{
			//cout <<"Small Sector "<<sector<<endl;
			Average_S_A[PCB]+= (Multiplicity[sector][PCB])/8.;
			Average_S_C[PCB]+= (Multiplicity_C[sector][PCB])/8.;
		}
	}
    }

for (int PCB = 1; PCB < 9; PCB++){           
	double stdev_square_L_A = 0.;
	double stdev_square_L_C = 0.;
	double stdev_square_S_A = 0.;
	double stdev_square_S_C = 0.;

	for (int sector = 1; sector < 17; sector++){
		int p = sector / 2;
		
		
        	if (sector - 2 * p == 0){
        	stdev_square_L_A += TMath::Power(Average_L_A[PCB]-Multiplicity[sector][PCB],2)/7.;
        	stdev_square_L_C += TMath::Power(Average_L_C[PCB]-Multiplicity_C[sector][PCB],2)/7.;
        			}
		else{
		stdev_square_S_A+= TMath::Power(Average_S_A[PCB]-Multiplicity[sector][PCB],2)/7.;
		stdev_square_S_C+= TMath::Power(Average_S_C[PCB]-Multiplicity_C[sector][PCB],2)/7.;
		    }
	
	}
	Error_L_A[PCB] = TMath::Sqrt(stdev_square_L_A)/TMath::Sqrt(8.);
	Error_L_C[PCB] = TMath::Sqrt(stdev_square_L_C)/TMath::Sqrt(8.);
	Error_S_A[PCB] = TMath::Sqrt(stdev_square_S_A)/TMath::Sqrt(8.);
	Error_S_C[PCB] = TMath::Sqrt(stdev_square_S_C)/TMath::Sqrt(8.);
	
	
	/*cout<<"\nFor Large Sector at A side,the PCB "<<PCB <<": "<<Average_L_A[PCB] << " \u00B1 " << Error_L_A[PCB];
	cout<<"\nFor Large Sector at C side,the PCB "<<PCB <<": "<<Average_L_C[PCB] << " \u00B1 " << Error_L_C[PCB];
	cout<<"\nFor Small Sector at A side,the PCB "<<PCB <<": "<<Average_S_A[PCB] << " \u00B1 " << Error_S_A[PCB];
	cout<<"\nFor Small Sector at C side,the PCB "<<PCB <<": "<<Average_S_C[PCB] << " \u00B1 " << Error_S_C[PCB];
	*/
	}	
		
cout <<"\n\n\n\n\n";

///////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////                Multiplicity Graphs               ////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////




	TCanvas *canvas = new TCanvas("canvas", " Average Multiplicity per PCB ", 800, 600);
	canvas->Divide(2,2);

	double x[] = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0};
	double ex[] = {0.0, 0.0, 0.0,0.0, 0.0, 0.0, 0.0, 0.0};
	Color_t colors[16] = {kBlue, kRed, kGreen, kOrange, kMagenta, kCyan, kYellow, kViolet, kPink, kAzure, kTeal, kSpring, kGray, kBlack, kRed + 2, kBlue + 2};
	
	TGraphErrors *graph_L_A = new TGraphErrors(8,x,Average_L_A,ex,Error_L_A);
	TGraphErrors *graph_L_C = new TGraphErrors(8,x,Average_L_C,ex,Error_L_C);
	TGraphErrors *graph_S_A = new TGraphErrors(8,x,Average_S_A,ex,Error_S_A);
	TGraphErrors *graph_S_C = new TGraphErrors(8,x,Average_S_C,ex,Error_S_C);
	
	
	
	canvas->cd(1);
	graph_L_A->SetTitle("Large Sectors A side");
	graph_L_A->SetMarkerStyle(20);
        graph_L_A->SetMarkerColor(colors[5]);
        graph_L_A->GetXaxis()->SetTitle("X-axis");
        graph_L_A->GetYaxis()->SetTitle("Y-axis");
	graph_L_A->Draw("AP");
	
	canvas->cd(3);
	graph_S_A->SetTitle("Small Sectors A side");
	graph_S_A->SetMarkerStyle(20);
        graph_S_A->SetMarkerColor(colors[5]);
        graph_S_A->GetXaxis()->SetTitle("PCB");
        graph_S_A->GetYaxis()->SetTitle("average Myltiplicity");
	graph_S_A->Draw("AP");
	
	canvas->cd(4);
	graph_S_C->SetTitle("Small Sectors C side");
	graph_S_C->SetMarkerStyle(20);
        graph_S_C->SetMarkerColor(colors[5]);
        graph_S_C->GetXaxis()->SetTitle("PCB");
        graph_S_C->GetYaxis()->SetTitle("average Myltiplicity");
	graph_S_C->Draw("AP");
	
	
	canvas->cd(2);
	graph_L_C->SetTitle("Large Sectors C side");
	graph_L_C->SetMarkerStyle(20);
        graph_L_C->SetMarkerColor(colors[5]);
        graph_L_C->GetXaxis()->SetTitle("X-axis");
        graph_L_C->GetYaxis()->SetTitle("Y-axis");
	graph_L_C->Draw("AP");


	canvas->SaveAs("Average_Multiplicity_per_PCB.png");



///////////////////////////////////////////////////////////////////////////////////////////////
///////////////////                SIGNIFICANCE CALCULATE               ///////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////	


 	double significance_L_A[16][8];
 	double significance_L_C[16][8];
 	double significance_S_A[16][8];
 	double significance_S_C[16][8];
	double significance_A[8][8];
	double significance_C[8][8];	
	
	
	for(int sector = 0; sector < 8 ; sector++){
		for (int PCB = 0; PCB < 8; PCB++){
			significance_L_A[sector][PCB] = 0.;
			significance_L_C[sector][PCB] = 0.;
			significance_S_A[sector][PCB] = 0.;
			significance_S_C[sector][PCB] = 0.;
			significance_A[sector][PCB] = 0.;
			significance_C[sector][PCB] = 0.;
		}
	}



	for(int PCB = 0; PCB < 8 ; PCB++){
		for (int sector = 0; sector < 16 ; sector++){
			
			significance_A[sector][PCB] = TMath::Abs(Average_L_A[PCB]-Multiplicity[sector+1][PCB+1])/Error_L_A[PCB+1];
			significance_C[sector][PCB] = TMath::Abs(Average_L_C[PCB]-Multiplicity_C[sector+1][PCB+1])/Error_L_C[PCB+1];
			
		}
	}

	for(int PCB = 0; PCB < 8 ; PCB++){
		for (int sector = 0; sector < 16 ; sector++){
			cout<<"\nFor Large Sector at A side (" <<sector <<","<< PCB <<") = "<<significance_A[sector][PCB];
			cout<<"\nFor Large Sector at C side (" <<sector <<","<< PCB <<") = "<<significance_C[sector][PCB];
		}
	}






}