initial commit

.gitignore

+*~
+*.root
+*.cal

AculData/AculCalibration.cpp

+//////////////////////////////////////////////////////////
+//									//
+//	AculCalibration					//
+//									//
+//
+//Some description of this very useful class,
+//its properties and a short example how to
+//use it. This text may be partly used in
+//PhD thesis.
+//
+//Description of the detector itself.
+//
+//														//
+//////////////////////////////////////////////////////////
+
+#include "AculCalibration.h"
+
+ClassImp(AculCalibration);
+
+AculCalibration::AculCalibration()
+{
+	//default constructor
+
+	fCurrentHStack = NULL;
+	fCurrentHistList.IsOwner();
+
+	kRaNOPEAKS = 0;
+	fLowerPeakRelativeHight = 0.;
+	fUpperPeakRelativeHight = 0.;
+	fPeakPositionTolerance = 0.;
+	fFitFuncLineWidth = 1;
+	fFitMinSigma = 0.;
+	fFitPeakThreshold = 0.;
+
+	for(Int_t i = 0; i < DEFAULTNOPEAKS; i++) {
+		fEnergy[i] = 0;
+	}
+	fCalInformation = 0;
+
+	Reset();
+
+}
+
+AculCalibration::AculCalibration(const char* parfile)
+{
+	//constructor which fills fA, fB, fC, fD from file parfile
+
+	fCurrentHStack = NULL;
+	fCurrentHistList.IsOwner();
+
+	kRaNOPEAKS = 0;
+	fLowerPeakRelativeHight = 0.;
+	fUpperPeakRelativeHight = 0.;
+	fPeakPositionTolerance = 0.;
+	fFitFuncLineWidth = 1;
+	fFitMinSigma = 0.;
+	fFitPeakThreshold = 0.;
+
+	for(Int_t i = 0; i < DEFAULTNOPEAKS; i++) {
+		fEnergy[i] = 0;
+	}
+
+	fCalInformation = 0;
+
+	SetCalibrationParameters(parfile);
+
+}
+
+AculCalibration::~AculCalibration()
+{
+
+	DeleteStacks();
+//	delete fCalInformation;
+//	fCalInformation->Close();
+
+}
+
+Int_t AculCalibration::SearchPeaks(const TH1 *hin, Double_t sigma, Option_t *option, const Int_t searchedpeaks)
+{
+	//Function searching peaks in inputed TH1 spectrum and selects the peaks in the histogram.
+	//
+	//  hin:
+	//  sigma:
+	//  option:
+	//  threshold:
+	//  searchedpeaks:
+
+	TSpectrum sc;	//by default for 100 peaks
+	Int_t nopeaks = sc.Search(hin, sigma, "goff", fFitPeakThreshold);
+
+	TString opt = option;
+	opt.ToLower();
+
+	const Double_t tStep = 0.05;
+
+	while ( nopeaks > searchedpeaks && fFitPeakThreshold <= 1) {
+		fFitPeakThreshold = fFitPeakThreshold + tStep;
+		nopeaks = sc.Search(hin, sigma, "goff", fFitPeakThreshold);
+	}
+
+	if (!nopeaks) {
+		return 0;
+	}
+
+	if (opt.Contains("goff")) {
+		return nopeaks;
+	}
+
+	TPolyMarker *pm = (TPolyMarker*)hin->GetListOfFunctions()->FindObject("TPolyMarker");
+	if (pm) {
+		hin->GetListOfFunctions()->Remove(pm);
+		delete pm;
+	}
+	pm = new TPolyMarker(nopeaks, sc.GetPositionX(), sc.GetPositionY());
+	hin->GetListOfFunctions()->Add(pm);
+	pm->SetMarkerStyle(23);
+	pm->SetMarkerColor(kRed);
+	pm->SetMarkerSize(1.3);
+
+	return nopeaks;
+}
+
+Int_t AculCalibration::PeaksFitting(TH1* hSpectrum, Option_t* option, Double_t sigmamin)
+{
+
+	if (!hSpectrum) return 1;
+	Int_t dimension = hSpectrum->GetDimension();
+	if (dimension > 1) {
+		Error("PeaksFitting", "Only implemented for 1-d histograms");
+		return 1;
+	}
+
+	TString	opt = option;
+	opt.ToLower();
+
+	if (!kRaNOPEAKS) {
+		Error("PeaksFitting", "kRaNOPEAKS is set to zero; calibration spectrum must be set");
+		return 1;
+	}
+
+	Int_t peaksNumber =	SearchPeaks(hSpectrum, sigmamin, "", kRaNOPEAKS);
+
+	if (peaksNumber != kRaNOPEAKS) {
+		Info("PeaksFitting", "In histogram %s was found %d peaks", hSpectrum->GetName(), peaksNumber);
+		return 1;
+	}
+
+	//should be optional output
+	Info("PeaksFitting", "Number of peaks in %s: %d", hSpectrum->GetName(), peaksNumber);
+
+	//working array for peaks, there are founded in accidental order
+	Double_t peak[peaksNumber];
+	Double_t *peakPosition;
+	Double_t *peakHight;
+
+	TList *functions = hSpectrum->GetListOfFunctions();
+	TPolyMarker *pm = (TPolyMarker*)functions->FindObject("TPolyMarker");
+
+	peakPosition = pm->GetX();
+	peakHight = pm->GetY();
+
+	for (Int_t i = 0; i < peaksNumber; i++) {
+
+		Double_t fitMin = 0;
+		Double_t fitMax = 0;
+		Double_t fitStep = hSpectrum->GetXaxis()->GetBinWidth(0);
+//		cout << fitStep << endl;
+//		cout << fLowerPeakRelativeHight << "\t" << fUpperPeakRelativeHight << endl;
+
+		//fitting range:
+		//shift a range of fit and search for raw boarder of peak determined by fUpperPeakRelativeHight
+		//maximum
+		Int_t j = 0;
+		Double_t currentHight = peakHight[i];
+		while ( currentHight > (peakHight[i]*fUpperPeakRelativeHight) ) {
+			j++;
+			fitMax = static_cast<Double_t>(peakPosition[i]) + j*fitStep;
+			currentHight = hSpectrum->GetBinContent(hSpectrum->GetXaxis()->FindBin(fitMax));
+		}
+
+		//minimum
+		j = 0;
+		currentHight = peakHight[i];
+		while ( currentHight > (peakHight[i]*fLowerPeakRelativeHight) ) {
+			j++;
+			fitMin = static_cast<Double_t>(peakPosition[i]) - j*fitStep;
+			currentHight = hSpectrum->GetBinContent(hSpectrum->GetXaxis()->FindBin(fitMin));
+		}
+
+		//fitting
+		if (opt.Contains("gp")) {
+			Info("PeaksFitting", "Option containing gp");
+			char fncname[20];
+			sprintf(fncname, "gaus_aux_%d", i);
+			TF1 *gausAux = new TF1(fncname, "gaus", fitMin - 10, fitMax + 10);		//pomocny gaus
+			hSpectrum->Fit(fncname, "0 Q", "", fitMin - 15, fitMax + 15);				//prvotni fitovani
+
+			sprintf(fncname, "auto_gp_%d", i);
+			TF1 *fitAuto = new TF1(fncname, "gaus(0) + pol0(3)", fitMin - 15, fitMax + 15);		//fce pro automaticke fitovani
+			fitAuto->SetParameter(0, gausAux->GetParameter(0));		//nastavovani parametru fitovaci fce
+			fitAuto->SetParameter(1, gausAux->GetParameter(1));
+			fitAuto->SetParameter(2, gausAux->GetParameter(2));
+
+			hSpectrum->Fit(fncname, "0 R Q +", "", fitMin - 15, fitMax + 15); //dodelat zapis vsech fci
+			hSpectrum->GetFunction(fncname)->ResetBit(TF1::kNotDraw);
+			peak[i] = fitAuto->GetParameter(1);			//zapis asi pozice v kanalech do pomocneho pole
+			if (opt.Contains("V")) {
+				Info("PeaksFitting", "Peak position is\t %4.2f \tresolution is \t %2.1f %%", fitAuto->GetParameter(1), 235*(fitAuto->GetParameter(2))/(fitAuto->GetParameter(1)));
+			}
+		}
+		else {
+			char fncname[20];
+			sprintf(fncname, "auto_g%d", i);
+			TF1 *fitAuto = new TF1(fncname, "gaus", fitMin, fitMax);		//fce pro automaticke fitovani
+//			cout << fitMin << "\t" << fitMax << endl;
+//			fitAuto->SetParameter(2, fitMax-fitMin);
+			fitAuto->SetLineWidth(fFitFuncLineWidth);
+			hSpectrum->Fit(fncname, "+ 0 R Q", ""/*, fitMin - 1, fitMax + 1*/);
+//			hSpectrum->GetFunction(fncname)->ResetBit(TF1::kNotDraw);
+			hSpectrum->GetFunction(fncname)->InvertBit(TF1::kNotDraw);
+			peak[i] = fitAuto->GetParameter(1);			//zapis asi pozice v kanalech do pomocneho pole
+			if (opt.Contains("v")) {
+				Info("PeaksFitting", "Peak position is\t%4.2f\tresolution is \t%2.1f %%", fitAuto->GetParameter(1), 235*(fitAuto->GetParameter(2))/(fitAuto->GetParameter(1)));
+			}
+		}//else
+		//end of fitting
+	}//for over all analyzed peaks
+
+	//peaks sorting
+	Int_t j[peaksNumber];
+	TMath::Sort(peaksNumber, peak, j, kFALSE);
+	for (Int_t i = 0; i < 4; i++) {
+		fPeak[i] = peak[j[i]];
+	}
+
+	if (!opt.Contains("q") || opt.Contains("v")) {
+		Info("PeaksFitting", "Control output:");
+		for (Int_t i = 0; i < peaksNumber; i++) {
+			printf("\tPeak position is\t%f\n", fPeak[i]);
+		}
+	}
+
+	//	provest kontrolu pomerne polohy piku,
+	//	jestli jsou spatne, provest urcita opatreni,
+	//	napr. zapis daneho histogramu do souboru,
+	//	zapis do souboru s chybama, vypis na obrazovku, ...
+	for (Int_t i = 0; i < peaksNumber; i++) {
+		if ( !( (((1-fPeakPositionTolerance)*(fEnergy[0]/fEnergy[i])) < (fPeak[0]/fPeak[i])) && (((1+fPeakPositionTolerance)*(fEnergy[0]/fEnergy[i])) > (fPeak[0]/fPeak[i])) ) ) {
+			if (fCalInformation && opt.Contains("writebad")) {
+				fCalInformation->cd();
+				hSpectrum->Write();
+			}
+			return 2;
+		}
+	}//for
+
+	return 0;
+}
+
+
+Bool_t AculCalibration::EnergyPositions(const char* inputfile, const char* block,
+			const Int_t address, const char* treename, Int_t lowerchannel,
+			Int_t upperchannel, Int_t lowersubaddress, Int_t uppersubaddress)
+{
+	TString iFile = inputfile;
+	TFile fr(iFile.Data());
+
+
+
+	return 1;
+}
+
+Bool_t AculCalibration::SetInputParameters(const char* inputparfile)
+{
+	const Int_t lineLength = 400;
+	Char_t	line[lineLength];
+	Char_t	parameter[100];
+	Char_t	identificator[100];
+
+
+	ifstream fipr;
+	fipr.open(inputparfile);
+	if (!fipr.is_open()) {
+		Error("SetInputsParameters", "File with input parameters was not opened");
+		return kFALSE;
+	}
+
+	while (!fipr.eof()) {
+
+		fipr.getline(line, lineLength);
+		if (strlen(line) == 0) {
+			continue;
+		}
+		sscanf(line, "%s %s", parameter, identificator);
+		if ( strcmp(identificator, "nopeaks") == 0 ) {
+			kRaNOPEAKS = static_cast<Int_t>(atoi(parameter));
+			for (Int_t i = 0; i < kRaNOPEAKS; i++) {
+				fipr.getline(line, lineLength);
+				sscanf(line, "%s", parameter);
+				fEnergy[i] = static_cast<Double_t>(atof(parameter));
+			}
+		}//if
+
+		if ( strcmp(identificator, "lowerchannel") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fLowerChannel = static_cast<Double_t>(atof(parameter));
+		}
+
+		if ( strcmp(identificator, "upperchannel") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fUpperChannel = static_cast<Double_t>(atof(parameter));
+		}
+
+		if ( strcmp(identificator, "lowerpeakhight") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fLowerPeakRelativeHight = static_cast<Double_t>(atof(parameter));
+		}
+
+		if ( strcmp(identificator, "upperpeakhight") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fUpperPeakRelativeHight = static_cast<Double_t>(atof(parameter));
+		}
+
+		if ( strcmp(identificator, "peakpositiontolerance") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fPeakPositionTolerance = static_cast<Double_t>(atof(parameter));
+		}
+
+		if ( strcmp(identificator, "fitfunctionlinewidth") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fFitFuncLineWidth = static_cast<Width_t>(atoi(parameter));
+		}
+
+		if ( strcmp(identificator, "minfitsigma") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fFitMinSigma = static_cast<Double_t>(atof(parameter));
+		}
+
+		if ( strcmp(identificator, "fithightthreshold") == 0 ) {
+			sscanf(line, "%s", parameter);
+			fFitPeakThreshold = static_cast<Double_t>(atof(parameter));
+		}
+
+	}
+
+
+	fipr.close();
+
+	return kTRUE;
+
+}
+
+void AculCalibration::PrintInputParameters()
+{
+	//print alpha source parameters
+
+	cout << "Number of peaks: " << kRaNOPEAKS << endl
+		<< endl;
+
+	for (Int_t i = 0; i < kRaNOPEAKS; i++) {
+		cout << "fEnergy[" << i << "] = " << fEnergy[i] << endl;
+	}
+
+
+	return;
+
+}
+
+Bool_t AculCalibration::SetCalibrationParameters(const char* calparfile)
+{
+
+	const Int_t lineLength = 200;
+	char line[lineLength];
+//	Int_t	crate;
+	char	crate[100];
+	Int_t	i, j;
+	char	cA[40], cB[40], cC[40], cD[40];
+
+	//open file with calibration parameters
+	ifstream calFileR;
+	calFileR.open(calparfile);
+
+
+	if( !calFileR.is_open() ) {
+		Error("SetCalibrationParameters", "File %s with calibration data was not opened", calparfile);
+		return kFALSE;
+	}
+
+	Reset();
+
+	//read calibration parameters from file
+	while (!calFileR.eof()) {
+		calFileR.getline(line, lineLength);
+		if ( line[0] != '*' && line[0] != '#' && line[0] != '%' && (line[0] != '/' && line[1] != '/') ) {		//possible comment characters
+			sscanf(line, "%s %d %d %s %s %s %s", crate, &i, &j, cA, cB, cC, cD);
+			fA[i][j] = atof(cA);
+			fB[i][j] = atof(cB);
+			fC[i][j] = atof(cC);
+			fD[i][j] = atof(cD);
+		}
+
+	}
+	calFileR.close();
+	return kTRUE;
+}
+
+void AculCalibration::PrintCalibrationParameters(const Int_t blockmin, const Int_t blockmax)
+{
+	for (Int_t i = blockmin; i <= blockmax; i++) {
+		for (Int_t j = 0; j < ADDRESSNUMBER; j++) {
+			cout << "C3[" << i << "][" << j << "]" << setw(10) << fA[i][j] << setw(10) << fB[i][j] << setw(10) << fC[i][j] << setw(10) << fD[i][j] << endl;
+		}
+	}
+}
+
+void AculCalibration::ShowRawSpectra(const char* filename, const Int_t block, TCanvas* rawCanvas, Int_t xaxismin, Int_t xaxismax, /*TObjArray* histList,*/ const Int_t subaddress)
+{
+	//Displays the spectrum from a file, divides the canvas into a sufficient number of pads and displays spectrums of each  
+	//block subaddress on the suitable pads.
+	//
+        //  filename: input .root file containing spectra to be showed
+	//  block: block which will be drawn
+	//  rawCanvas: canvas on which one you will see the spectrum
+	//  xaxismin: minimal channel, which will be displayed
+	//  xaxismax: maximal channel, which will be displayed
+	//  subaddress:
+
+	Char_t address[40];
+	Char_t histName[40];
+	Char_t fillCommand[40];
+	Char_t fillCondition[40];
+
+
+	if (!rawCanvas) {
+		//rawCanvas = new TCanvas("RawSpectra", "Raw spectra in channels", 1);
+		cout << "You have to assign TCanvas for raw spectra drawing" << endl;
+		return;
+	}
+
+	rawCanvas->Clear();
+
+//	cout << "hovno" << endl;
+
+	rawCanvas->SetFillColor(10);
+
+//	cout << "hovno" << endl;
+	TFile *fr = new TFile(filename);
+	if (fr->IsOpen() == 0) {
+		cout << endl << "File " << filename << " was not opened and won't be processed" << endl << endl;
+		return;
+	}
+	TH1I *hRead = 0;
+	TTree *tr = (TTree*)fr->Get("RAW");
+//	cout << "hovno" << endl;
+
+
+	if (subaddress > 15) {
+		rawCanvas->Divide(4, 4);
+		rawCanvas->SetFillColor(10);
+//		cout << "hovno" << endl;
+		for (Int_t i = 0; i < 16; i++) {
+			cout << i << endl;
+			rawCanvas->cd(i+1);
+			hRead = new TH1I("name", "title", 4096, 0, 4095);
+			sprintf(address, "C3[%d][%d]", block, i);
+			sprintf(histName, "H3[%d][%d]", block, i);
+			hRead->SetName(histName);
+			sprintf(fillCommand, "%s >> %s", address, hRead->GetName());
+			sprintf(fillCondition, "%s > 0", address);
+			tr->Draw(fillCommand, fillCondition, "");
+			if (hRead) {
+				hRead->SetDirectory(0);
+//				cout << hRead->GetEntries() << endl;
+//				if (fHRawList) {
+//					fHRawList->Add(hRead);
+					fHRawList.Add(hRead);
+//				}
+				hRead->SetAxisRange(xaxismin, xaxismax);
+			}
+		}//for
+	}
+	else {
+		fr->cd();
+		hRead = new TH1I("name", "title", 4096, 0, 4095);
+		sprintf(address, "C3[%d][%d]", block, subaddress);
+		sprintf(histName, "H3[%d][%d]", block, subaddress);
+		hRead->SetName(histName);
+		sprintf(fillCommand, "%s >> %s", address, hRead->GetName());
+		sprintf(fillCondition, "%s > 0", address);
+//		cout << fillCommand << setw(20) << fillCondition << endl;
+		tr->Draw(fillCommand, fillCondition, "goff");
+		if (hRead) {
+			hRead->SetDirectory(0);
+//			if (fHRawList) {
+//				fHRawList->Add(hRead);
+//			}
+			fHRawList.Add(hRead);
+			hRead->Draw();
+			hRead->SetAxisRange(xaxismin, xaxismax);
+		}
+	}//else
+
+	fr->Close();
+
+	rawCanvas->Update();
+
+	return;
+
+}
+
+void AculCalibration::ShowSpectra(const char* filename, TCanvas* rawCanvas, Option_t *option, Int_t xaxismin, Int_t xaxismax, const Int_t subaddress)
+{
+	//filename: input .root file with saved filled histograms to be showed
+	//rawCanvas: canvas on which one you will see the spectrum
+	//option: THStack options
+	//xaxismin: Minimum channel, which will be displayed
+	//xaxismax: Maximum channel, which will be displayed
+	//subaddress:
+ 
+	TString opt = option;
+	opt.ToLower();
+
+	if (!rawCanvas) {
+		Error("ShowRawSpectra", "You have to assign TCanvas for raw spectra drawing");
+		return;
+	}
+	rawCanvas->Clear();
+
+	TFile fr(filename);
+	if (fr.IsOpen() == 0) {
+		Error("ShowRawSpectra", "File %s was not opened and won't be processed", filename);
+		return;
+	}
+
+	TList *histList;
+	histList = fr.GetListOfKeys();
+	Int_t listEntries = histList->GetEntries();
+	TH1 *hDraw = 0;
+	DeleteStacks();
+
+	if (subaddress >= listEntries) {
+		fCurrentHStack = new THStack();
+		for (Int_t i = 0; i < listEntries; i++) {	//zkontrolovat hranice
+			Info("ShowRawSpectra", "Histogram with spectrum of subaddress %d is loading", i);
+			fr.GetObject(histList->At(i)->GetName(), hDraw);
+			if (hDraw) {
+				hDraw->SetDirectory(0);
+				//hDraw->SetAxisRange(xaxismax, xaxismin);	//nefunguje
+				fCurrentHistList.Add(hDraw);
+				fCurrentHStack->Add(hDraw);
+			}
+		}//for
+		if ( !fCurrentHStack->GetHists()->IsEmpty() ) {
+			Info("ShowRawSpectra", "Histogram stack drawing");
+			fCurrentHStack->Draw(opt.Data());
+		}
+	}//if all subaddresses
+	else {
+		//zkontrolovat
+		fr.GetObject(histList->At(subaddress)->GetName(), hDraw);
+		if (hDraw) {
+			hDraw->SetAxisRange(xaxismin, xaxismax, "X");
+			hDraw->Draw();
+			hDraw->SetDirectory(0);
+			fCurrentHistList.Add(hDraw);
+		}
+	}//else
+
+	fr.Close();
+	rawCanvas->Update();
+	return;
+}
+
+void AculCalibration::FillRawSpectraFile(const char* rawdatafile, const char* block, const char* treename, TCanvas* rawCanvas, Option_t *option, Int_t xaxismin, Int_t xaxismax)
+{
+	//filename: input .root file containing spectra to be showed
+	//block:
+	//rawCanvas:
+	//xaxismin:
+	//xaxismax:
+
+	//variables to be became function parameter
+	TString opt(option);
+	opt.ToLower();
+
+	if (!rawCanvas) {
+		Error("ShowRawSpectra", "You have to assign TCanvas for raw spectra drawing");
+		return;
+	}
+	rawCanvas->Clear();
+
+	TFile fr(rawdatafile);
+	if (fr.IsOpen() == 0) {
+		Error("ShowRawSpectra", "File %s was not opened and won't be processed", rawdatafile);
+		return;
+	}
+	TTree *tr = (TTree*)fr.Get(treename);
+
+	char outputfile[300];
+	sprintf(outputfile, "%s[]Raw.root", block);
+	TFile fw(outputfile, opt.Data());
+	if (fw.IsOpen() == 0) {
+		Error("CalculateCalibParameters", "Output file %s was not created.", outputfile);
+		return;
+	}
+	if (fw.IsWritable() == 0) {
+		Error("CalculateCalibParameters", "Output file %s is not writable. Set option to \"RECREATE\".", outputfile);
+		return;
+	}
+
+	char address[40];
+	char histName[40];
+	char histTitle[40];
+	char fillCommand[40];
+	char fillCondition[40];
+
+	fw.cd();
+	TH1I *hRead = 0;
+
+	for (Int_t i = 0; i < 16; i++) {	//zkontrolovat hranice
+		cout << i << endl;	//predelat na info
+		hRead = new TH1I("name", "title", 4096, 0, 4095);
+		sprintf(address, "%s[%d]", block, i);
+		sprintf(histName, "%s[%d]", block, i);
+		sprintf(histTitle, "%s : %s", rawdatafile, histName);
+		hRead->SetName(histName);
+		hRead->SetTitle(histTitle);
+		sprintf(fillCommand, "%s >> %s", address, hRead->GetName());
+		sprintf(fillCondition, "%s > 0", address);
+		tr->Draw(fillCommand, fillCondition, "goff");		//prozkoumat goff
+		hRead->Write();
+	}//for
+
+	fw.Close();
+	fr.cd();
+	delete tr;
+	fr.Close();
+
+	rawCanvas->Update();
+
+	return;
+}
+
+Bool_t AculCalibration::CalculateCalibParameters(const char* inputfile, const char* block, const Int_t address,
+		const char* treename, Int_t lowerchannel, Int_t upperchannel, Int_t nEBins, Int_t lowersubaddress,
+		Int_t uppersubaddress)
+{
+	if (kRaNOPEAKS == 0) {
+		Error("CalculateCalibParameters", "Alpha source parameters was not read");
+		return 0;
+	}
+
+	if ( (address > BLOCKSNUMBER) || (address < 1) ) {
+		Error("CalculateCalibParameters", "Possible address values have to be in range 1 - %d", BLOCKSNUMBER - 1);
+		return kFALSE;
+	}
+
+	//muzu nechat
+	if ( (uppersubaddress - lowersubaddress) >= ADDRESSNUMBER ) {
+		Error("CalculateCalibParameters", "Possible subaddress values have to be in range 0 - %d", ADDRESSNUMBER - 1);
+		return 0;
+	}
+
+	//auxiliary variables, particularly for text parameter fields
+	TString oFileName;
+
+	//creation of the output text file
+	if ( (lowersubaddress == 0) && (uppersubaddress == ADDRESSNUMBER-1) ) { oFileName.Form("%s[].cal", block); }
+	else {
+		if (lowersubaddress == uppersubaddress) { oFileName.Form("%s[%d].cal", block, lowersubaddress); }
+		else { oFileName.Form("%s[%d-%d].cal", block, lowersubaddress, uppersubaddress); }
+	}//if
+
+	ofstream outcalfile;
+	outcalfile.open(oFileName.Data());
+	if (!outcalfile.is_open()) {
+		Error("CalculateCalibParameters", "Output file %s was not opened", oFileName.Data());
+		return 0;
+	}//if
+
+	//creation of the output root file
+	if ( (lowersubaddress == 0) && (uppersubaddress == ADDRESSNUMBER-1) ) { oFileName.Form("%s[].root", block); }
+	else {
+		if (lowersubaddress == uppersubaddress) { oFileName.Form("%s[%d].root", block, lowersubaddress); }
+		else { oFileName.Form("%s[%d-%d].root", block, lowersubaddress, uppersubaddress); }
+	}
+	fCalInformation = new TFile(oFileName.Data(), "RECREATE");
+	if ( !fCalInformation->IsOpen() ) {
+		Error("CalculateCalibParameters", "File %s was not opened and won't be processed", oFileName.Data());
+		return 0;
+	}
+
+	//input file with raw data opening
+	TString iFileName = inputfile;
+	TFile *fr = new TFile(iFileName.Data());
+	if ( !fr->IsOpen() ) {
+		Error("CalculateCalibParameters", "File %s was not opened and won't be processed", iFileName.Data());
+		return 0;
+	}
+	TTree *tr = (TTree*)fr->Get(treename);
+	if (!tr) {
+		Error("CalculateCalibParameters", "Tree %s was not found in file %s", treename, iFileName.Data());
+		return 0;
+	}
+
+
+	//promenne potrebne pro fitovani: presunout nize
+	//pohlidat delete
+	TF1 	*calFunction = new TF1("calib", "pol1", 0, 1000);	//predelat jako lokalni promennou fce (nebo snad tridy?)
+	TGraph 	*calGraph = new TGraph(kRaNOPEAKS, fPeak, fEnergy); //lokalni promenna, dohodit pocet vstupu pomoci parametru
+
+	TString	detectorChannel;
+	TString	histName;
+	TString histTitle;
+	TString fillCommand;
+	TString	fillCondition;
+	Int_t	fitControl = 0;
+
+	//predelat nazvy histogramu
+	//zrusit cyklus, napsat jako fci
+	//raw data histogram filling
+	TH1I *hRaw = 0;
+	TH1F *hEnergy = 0;
+
+	TRandom3 ranGen(1);
+
+	//outputfile with calibrated spectra
+	if ( (lowersubaddress == 0) && (uppersubaddress == ADDRESSNUMBER-1) ) { oFileName.Form("%s[]E.root", block); }
+	else {
+		if (lowersubaddress == uppersubaddress) { oFileName.Form("%s[%d]E.root", block, lowersubaddress); }
+		else { oFileName.Form("%s[%d-%d]E.root", block, lowersubaddress, uppersubaddress); }
+
+	}
+	TFile *fw = new TFile(oFileName.Data(), "RECREATE");
+	if (fw->IsOpen() == 0) {
+		Error("CalculateCalibParameters", "File %s was not created and won't be processed\n\n", oFileName.Data());
+		return 1;
+	}
+
+	for (Int_t i = lowersubaddress; i <= uppersubaddress; i++) {
+		printf("\n\n");
+		Info("CalculateCalibParameters", "Calculating calibration parameters for detector channel %s[%d].", block, i);
+		//TH1I object preparing
+		hRaw = new TH1I("name", "title", 4096, 0, 4095);					//nastavovat hranice histogramu podle parametru fce
+		detectorChannel.Form("%s[%d]", block, i);
+		histName.Form("Hist%s[%d]", block, i);
+		hRaw->SetName(histName.Data());
+		fillCommand.Form("%s >> %s", detectorChannel.Data(), hRaw->GetName());
+		fillCondition.Form("%s > %d && %s < %d",
+				detectorChannel.Data(), lowerchannel, detectorChannel.Data(), upperchannel);
+		//filling from the .root raw data file and content arrangement
+		tr->Draw(fillCommand.Data(), fillCondition.Data(), "goff");
+
+		//spectrum analysis
+		fitControl = PeaksFitting(hRaw, "Q", fFitMinSigma);
+		Info("CalculateCalibParameters", "Value of fitControl is: %d", fitControl);		//ok
+
+		//incorrectly treated spectrum output
+		if (fitControl != 0 && fCalInformation->IsOpen()) {															//ok
+			outcalfile << setw(39) << fitControl << endl;
+			fCalInformation->cd();
+			hRaw->SetLineColor(2);	//red
+			fCalInformation->cd();
+			hRaw->Write();
+			continue;
+		}//if
+
+		//correctly treated spectrum saving
+		if (fCalInformation->IsOpen()) {
+			fCalInformation->cd();
+			hRaw->SetLineColor(kGreen+3);	//green
+			hRaw->SetFillColor(kGreen+1);
+			hRaw->Write();
+		}//if
+
+		//calibration parameters calculation																//ok
+		for (Int_t j = 0; j < kRaNOPEAKS; j++) {		//delat podle poctu zkoumanych piku
+			calGraph->SetPoint(j, fPeak[j], fEnergy[j]);  //calibration graph filling
+		}//for
+		calGraph->Fit(calFunction, "Q", "goff", 0, 4096);  //omezit hlasitost fitovani, udelat volitelne, dodelat volby rozsahu
+		outcalfile
+			<< block << "\t"
+			<< address << "\t"
+			<< i << "\t"
+			<< setprecision(4) << calFunction->GetParameter(1) << "\t"
+			<< setprecision(4) << calFunction->GetParameter(0) << "\t\t"
+			<< fitControl
+			<< endl;
+		fA[address][i] = calFunction->GetParameter(1);
+		fB[address][i] = calFunction->GetParameter(0);
+
+
+		//calibration of raw spectra using obtained parameters
+		Info("CalculateCalibParameters", "Energy spectrum from address %s[%d] calculating", block, i);
+		histName.Form("%sE", hRaw->GetName());
+		histTitle.Form("%s: %s", iFileName.Data(), histName.Data());
+		hEnergy = new TH1F(histName.Data(), histTitle.Data(), nEBins, 0., 10.);
+		//			detectorChannel.Form("%s[%d]", block, i);
+		//			hEnergy->SetName(histName.Data());
+
+		for (Int_t j = lowerchannel; j < upperchannel; j++) {
+			Int_t binCont = (Int_t)hRaw->GetBinContent(j);
+			//				cout << j << ":\t" << hRaw->GetBinContent(j) << endl;
+			for (Int_t k = 0; k < binCont; k++) {
+				hEnergy->Fill( fA[address][i]*( j+ranGen.Uniform(-0.5, 0.5) ) + fB[address][i] );
+//				cout << j << ":\t" << fA[address][i]*( j+ranGen.Uniform(-0.5, 0.5) ) + fB[address][i] << endl;
+//				cout << j << ":\t" << fA[address][i] << endl;
+			}
+		}
+
+		fw->cd();
+		hEnergy->Write();
+
+	}//for
+
+	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	//zapis histogramu v MeV do souboru .root
+	//
+	//urcite by se to dalo hodit do samostatne fce
+	//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+	/*Char_t	histTitle[40];
+
+	//outputfile with calibrated spectra
+	if ( (lowersubaddress == 0) && (uppersubaddress == ADDRESSNUMBER-1) ) { oFileName.Form("%s[]E.root", block); }
+	else {
+		if (lowersubaddress == uppersubaddress) { oFileName.Form("%s[%d]E.root", block, lowersubaddress); }
+		else { oFileName.Form("%s[%d-%d]E.root", block, lowersubaddress, uppersubaddress); }
+
+	}
+	TFile *fw = new TFile(oFileName.Data(), "RECREATE");
+	if (fw->IsOpen() == 0) {
+		Error("CalculateCalibParameters", "File %s was not created and won't be processed\n\n", oFileName.Data());
+		return 1;
+	}
+
+	TH1F *hEnergy = 0;
+
+	TRandom3 ranGen(1);
+
+	Long64_t nEntries = tr->GetEntries();
+
+	for (Int_t i = lowersubaddress; i <= uppersubaddress; i++) {
+		Info("CalculateCalibParameters", "Calibration spectrum from address %s[%d]", block, i);
+		histName.Form("Hist%s[%d]E", block, i);
+		sprintf(histTitle, "%s: %s", iFileName.Data(), histName.Data());
+		hEnergy = new TH1F(histName.Data(), histTitle, 10000, 0., 10.);
+		detectorChannel.Form("%s[%d]", block, i);
+		hEnergy->SetName(histName.Data());
+		fillCommand.Form("%f*(%s+%f)+%f >> %s", fA[address][i], detectorChannel.Data(), ranGen.Uniform(-0.5, 0.5), fB[address][i], hEnergy->GetName());
+//		fillCommand.Form("%f*(%s+%f)+%f >> %s", fA[address][i], detectorChannel.Data(), 0., fB[address][i], hEnergy->GetName());
+		cout << fillCommand.Data() << endl;
+		fillCondition.Form("%s > %f && %s < %f", detectorChannel.Data(), fLowerChannel, detectorChannel.Data(), fUpperChannel);
+		//filling from the .root raw data file and content arrangement
+
+		for (Int_t j = 0; j < nEntries; j++) {
+
+		}
+
+		tr->Draw(fillCommand.Data(), fillCondition.Data(), "goff");
+
+
+		fw->cd();
+		hEnergy->Write();
+	}//for
+
+	fw->Close();*/
+
+	fw->Close();
+	fr->Close();
+	fCalInformation->Close();
+	outcalfile.close();
+
+	return 1;
+
+}
+
+
+
+void AculCalibration::ShowAnalyzedSpectra(const char *filename, TCanvas* fittedRawCanvas, Int_t xaxismin, Int_t xaxismax, Int_t subaddress)
+{
+
+	if ( subaddress > ADDRESSNUMBER ) {
+		Error("ShowAnalyzedSpectra", "Possible subaddress values have to be in range 0 - %d", ADDRESSNUMBER - 1);
+		return;
+	}
+
+	if (!fittedRawCanvas) {
+		Warning("ShowAnalyzedSpectra", "You have to assign TCanvas for fitted raw spectra drawing");
+		return;
+	}
+
+
+	TFile *fr = new TFile(filename, "READ");
+	if (!fr->IsOpen()) {
+		cout << "File " << filename << " was not opened" << endl;
+		return;
+	}
+
+	TList *histList;
+	histList = fr->GetListOfKeys();
+	Int_t listEntries = histList->GetEntries();
+	TH1I *hDraw = 0;
+
+	fittedRawCanvas->Clear();
+//	fittedRawCanvas->SetFillColor(10);
+
+	if ( (listEntries > 1) && (listEntries <= 8) ) {
+		fittedRawCanvas->Divide(2, 4);
+		fittedRawCanvas->SetFillColor(10);
+	}
+	if ( (listEntries > 8) && (listEntries <= 16) ) {
+		fittedRawCanvas->Divide(4, 4);
+		fittedRawCanvas->SetFillColor(10);
+	}
+
+	if (subaddress >= listEntries) {
+		for (Int_t i = 0; i < listEntries; i++) {
+			fittedRawCanvas->cd(i+1);
+			fr->GetObject(histList->At(i)->GetName(), hDraw);
+			if (hDraw) {
+				hDraw->SetAxisRange(xaxismin, xaxismax, "X");
+				hDraw->Draw();
+				hDraw->SetDirectory(0);
+//				if (fHAnalyzedList) {
+//					fHAnalyzedList->Add(hDraw);
+//				}
+				fHAnalyzedList.Add(hDraw);
+			}
+		}//for
+	}
+	else {
+		fr->GetObject(histList->At(subaddress)->GetName(), hDraw);
+		if (hDraw) {
+			hDraw->SetAxisRange(xaxismin, xaxismax, "X");
+			hDraw->Draw();
+			hDraw->SetDirectory(0);
+			fHAnalyzedList.Add(hDraw);
+		}
+	}
+
+	fr->Close();
+
+	fittedRawCanvas->Update();
+
+	return;
+
+}
+
+void AculCalibration::ShowEnergySpectra(const char *filename, TCanvas* energyCanvas, const Int_t subaddress, Option_t* option, Double_t xaxismin, Double_t xaxismax)
+{
+	if ( subaddress > ADDRESSNUMBER ) {
+		Error("ShowEnergySpectra", "Possible subaddress values have to be in range 0 - %d", ADDRESSNUMBER - 1);
+		return;
+	}
+
+	if (!energyCanvas) {
+		Warning("ShowEnergySpectra", "You have to assign TCanvas for fitted raw spectra drawing");
+		return;
+	}
+
+	TString	opt = option;
+	opt.ToLower();
+
+	TFile *fr = new TFile(filename, "READ");
+	if (!fr->IsOpen()) {
+		cout << "File " << filename << " was not opened" << endl;
+		return;
+	}
+
+	TList *histList;
+	histList = fr->GetListOfKeys();
+	Int_t listEntries = histList->GetEntries();
+	TH1F *hDraw = 0;
+
+	energyCanvas->Clear();
+	energyCanvas->SetFillColor(10);
+	if ( (listEntries > 1) && (listEntries <= 8) ) {
+		energyCanvas->Divide(2, 4);
+		energyCanvas->SetFillColor(10);
+	}
+	if ( (listEntries > 8) && (listEntries <= 16) ) {
+		energyCanvas->Divide(4, 4);
+		energyCanvas->SetFillColor(10);
+	}
+
+
+	if (subaddress >= listEntries) {
+		if (opt.Contains("sum")) {
+			energyCanvas->cd(0);
+			for (Int_t i = 0; i < listEntries; i++) {
+				fr->GetObject(histList->At(i)->GetName(), hDraw);
+				if (hDraw) {
+					hDraw->SetDirectory(0);
+					//hDraw->SetAxisRange(xaxismin, xaxismax, "X");
+					if (opt.Contains("c")) { hDraw->SetLineColor(i+1); }
+					if (opt.Contains("c") && opt.Contains("+")) { hDraw->SetFillColor(i+1); }
+//					fHEnergyStack->Add(hDraw);
+					fHEnergyStack.Add(hDraw);
+				}
+			}
+//			if (fHEnergyStack) {
+//				if (opt.Contains("+")) { fHEnergyStack->Draw(); }
+//				else { fHEnergyStack->Draw("nostack"); }
+//			}
+			if (opt.Contains("+")) { fHEnergyStack.Draw(); }
+			else { fHEnergyStack.Draw("nostack"); }
+		}
+		else {
+			for (Int_t i = 0; i < listEntries; i++) {
+				energyCanvas->cd(i+1);
+				fr->GetObject(histList->At(i)->GetName(), hDraw);
+				if (hDraw) {
+					hDraw->SetAxisRange(xaxismin, xaxismax, "X");
+					hDraw->Draw();
+					hDraw->SetDirectory(0);
+//					if (fHEnergyList) {
+//						fHEnergyList->Add(hDraw);
+//					}
+					fHEnergyList.Add(hDraw);
+				}
+			}//for
+		}//else
+	}//if
+	else {
+		fr->GetObject(histList->At(subaddress)->GetName(), hDraw);
+		energyCanvas->cd(0);
+		if (hDraw) {
+			hDraw->SetAxisRange(xaxismin, xaxismax, "X");
+			hDraw->Draw();
+			hDraw->SetDirectory(0);
+//			if (fHEnergyList) {
+//				fHEnergyList->Add(hDraw);
+//			}
+			fHEnergyList.Add(hDraw);
+		}
+	}//else
+
+	fr->Close();
+
+//	fFileName = filename;
+//	fFileName.Resize(fFileName.Length() - 6);
+//	fFileName.Append(".cal", 4);
+
+	energyCanvas->Update();
+
+	return;
+
+}
+
+Bool_t AculCalibration::AddCalFileToList(const char* calfilelist)
+{
+	//this function does not work at the moment
+	//some problem with TString object fFileName
+
+	TString fl = calfilelist;
+	fl.ToLower();
+
+	ofstream fw;
+	fw.open(fl.Data(), ofstream::app);
+	if (!fw.is_open()) {
+		cout << "File " << fl.Data() << " was not opened" << endl;
+		return kFALSE;
+	}
+
+//	fw << fFileName.Data() << endl;
+
+	fw.close();
+
+	return kTRUE;
+
+}
+
+void AculCalibration::ClearHistograms(Option_t* option)
+{
+	//clear THStack and TObjArray members
+	//this function will be removed as soon as possible
+
+	TString opt = option;
+	opt.ToLower();
+
+//	fHRawList->Add(hRead);
+	fHRawList.Clear();
+	fHAnalyzedList.Clear();
+	fHEnergyList.Clear();
+	fHEnergyStack.Clear();
+
+	return;
+
+}
+
+void AculCalibration::MakeCalibrationFile(Char_t* calibrationfile, Char_t *calfilelist)
+{
+	//calibrationfile: file with calibration parameters to be created
+	//calfilelist: file containing list of existing text files with calibration parameters
+
+	ifstream calListR;
+	calListR.open(calfilelist);
+	if( !calListR.is_open() ) {
+		cout << "File with list of calibration files was not opened" << endl;
+		return;
+	}
+
+	//asi fce Reset()
+	for (Int_t i = 0; i < BLOCKSNUMBER; i++) {
+		for (Int_t j = 0; j < ADDRESSNUMBER; j++) {
+			fA[i][j] = 0;
+			fB[i][j] = 0;
+		}
+	}
+
+	const Int_t lineLength = 100;
+	char line[lineLength];
+	char filename[50];
+//	ifstream calFileR;
+	Int_t	crate, i, j, id;
+//	int	crate, i, j, id;
+	char	cA[40], cB[40], cSigma[40];
+
+	while (!calListR.eof()) {
+		calListR.getline(line, lineLength);
+//		cout << line << endl;
+		sscanf(line, "%s", filename);
+		cout << filename << endl;
+		ifstream calFileR;
+		calFileR.open(filename);
+		if (calFileR.is_open()) {
+			cout << filename << " processing" << endl;
+			calFileR.seekg(0);
+			while (!calFileR.eof()) {
+//				cout << " in inner while" << endl;
+				calFileR.getline(line, lineLength);
+				sscanf(line, "%d %d %d %s %s %d %s", &crate, &i, &j, cA, cB, &id, cSigma);
+//				cout << line << endl;
+				if (id == 0) {
+					fA[i][j] = static_cast<Double_t>(atof(cA));
+					fB[i][j] = static_cast<Double_t>(atof(cB));
+	//				fMeanSigma[i][j] = static_cast<Double_t>(atof(cSigma));
+					cout << fA[i][j] << "\t" << fB[i][j] << endl;
+				}//if
+			}//while
+			calFileR.close();
+			cout << "calFileR was closed" << endl << endl;
+		}//if
+	}//while
+
+	calListR.close();
+
+	ofstream CalibFileW;
+	CalibFileW.open(calibrationfile);
+	if (!CalibFileW.is_open()) {
+		cout << "Calibration file was not opened" << endl;
+		return;
+	}
+
+	for (Int_t i = 0; i < BLOCKSNUMBER; i++) {
+		for (Int_t j = 0; j < ADDRESSNUMBER; j++) {
+			if (fA[i][j] != 0) {
+				CalibFileW << std::right
+					<< setw(2) << "3"
+					<< setw(4) << i
+					<< setw(4) << j
+					<< setw(12) << fA[i][j]
+					<< setw(12) << fB[i][j]
+	//				<< setw(10) << fMeanSigma[i][j]
+					                     << endl;
+			}
+		}
+	}
+
+	CalibFileW.close();
+
+	return;
+
+}
+
+void AculCalibration::DeleteStacks(Option_t* option) {
+
+	if (fCurrentHStack) {
+		delete fCurrentHStack;
+		fCurrentHStack = NULL;
+	}
+
+	fCurrentHistList.Delete();
+
+	return;
+}
+
+void AculCalibration::Reset()
+{
+	//reset calibration parameters fA, fB, fC, fD to zero
+
+	for (Int_t i = 0; i < BLOCKSNUMBER; i++) {
+		for (Int_t j = 0; j < ADDRESSNUMBER; j++) {
+			fA[i][j] = 0;
+			fB[i][j] = 0;
+			fC[i][j] = 0;
+			fD[i][j] = 0;
+	//		fMeanSigma[i][j] = 0;
+		}
+	}
+
+	return;
+}

AculData/AculCalibration.h

+#pragma once
+
+#include <TObject.h>
+#include <TFile.h>
+#include <TTree.h>
+#include <TH1I.h>
+#include <TPolyMarker.h>
+#include <TF1.h>
+#include <TH1F.h>
+#include <TH2F.h>
+#include <TCanvas.h>
+#include <TMath.h>
+#include <TGraph.h>
+#include <TObjArray.h>
+#include <TRandom3.h>
+#include <THStack.h>
+#include <TString.h>
+#include <TSpectrum.h>
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <sstream>
+
+#define DEFAULTNOPEAKS 20
+#define	BLOCKSNUMBER 100
+#define ADDRESSNUMBER 32
+
+using std::cout;
+using std::endl;
+using std::setw;
+using std::setprecision;
+using std::stringstream;
+using std::ostringstream;
+
+class AculCalibration : public TObject
+{
+
+
+public:
+
+	//smysl jako verejne globalni promenne maji:
+	//fNOSpectra	- pocet zkalibrovanych spekter
+	//????			- pocet spravne zkalibrovanych spekter
+	//????			- pocet nespravne zkalibrovanych spekter
+	//fEnergy[4]	- tabulka s energiemi piku, nacita se zvenci
+
+//private:
+
+
+//	TObjArray	*fHRawList;			//list of raw histograms, list is set to owner
+	TObjArray	fHRawList;			//list of raw histograms, list is set to owner
+	TObjArray	fHAnalyzedList;	//list of fitted and analyzed histograms, list is set to owner
+	TObjArray	fHEnergyList;		//list of calibrated histograms, list is set to owner
+	THStack		fHEnergyStack;		//some stack
+	THStack		*fCurrentHStack;
+	//dodelat current histograms
+	TObjArray	fCurrentHistList;
+
+
+
+//	TRandom3	*fRanGen;
+//	static TRandom3 fRanGen;	//!
+//	THStack		*fHStack;
+
+	//parameters to be read from file
+	Int_t		kRaNOPEAKS;
+	Double_t	fEnergy[DEFAULTNOPEAKS];
+	Double_t	fLowerChannel;
+	Double_t	fUpperChannel;
+	Double_t	fLowerPeakRelativeHight;	//pouziva se, private
+	Double_t	fUpperPeakRelativeHight;	//pouziva se, private, nastavit nenulovou prednastavenou hodnotu
+	Double_t	fPeakPositionTolerance;		//pouziva se, private
+	Width_t		fFitFuncLineWidth;			//private
+	Double_t	fFitMinSigma;				//pouziva se, private
+	Double_t	fFitPeakThreshold;			//pouziva se, private, prozkoumat, k cemu vlastne slouzi ve fci ShowPeaks, popremyslet o vhodnem prednastaveni v konstruktoru
+
+	//tyto promenne jsou smyslem tridy, mely by tedy byt snad jako jedine verejne
+	Double_t	fA[BLOCKSNUMBER][ADDRESSNUMBER];	//kalibracni parametry, f(x) = fA*x + fB
+	Double_t	fB[BLOCKSNUMBER][ADDRESSNUMBER];	//kalibracni parametry, f(x) = fA*x + fB
+	Double_t	fC[BLOCKSNUMBER][ADDRESSNUMBER];	//treti kalibracni parametr, jine zavislosti nez pol1
+	Double_t	fD[BLOCKSNUMBER][ADDRESSNUMBER];	//ctvrty kalibracni parametr
+
+
+
+
+
+	//smysl je velmi pochybny
+	TFile		*fCalInformation;
+
+//private:
+	Double_t	fPeak[DEFAULTNOPEAKS];				//v teto promenne je ulozena momentalni hodnota piku v kanalech, zejmena v jedne fci, mozno udelat ji jako lokalni, bude navratovou hodnotou fce PeaksFitting, predelat delku pole
+
+public:
+	AculCalibration();
+	//default constructor
+	AculCalibration(const char* parfile);		//
+	virtual ~AculCalibration();
+
+	Bool_t	SetInputParameters(const char* inputparfile = "parforcal.par");
+	// Function which loads text file containing parameters for calibration
+	//
+	//	-inputparfile: file containing information on calibration source
+	//	-In file with the data must be preserved systematic
+	//	-There cannot be whitelines (probably)
+	//
+	//Example of "parforcal.par" file
+	//................................................................
+	//223Ra
+	//
+	//4		nopeaks		//number of peaks
+	//4.415		E1		//in MeV
+	//5.153		E2		//in MeV
+	//5.683		E3		//in MeV
+	//7.419		E4		//in MeV
+	//100		lowerchannel	//in channels
+	//4096		upperchannel	//in channels
+	//0.1		lowerpeakhight		//in relative units
+	//0.1		upperpeakhight		//in relative units
+	//0.1		peakpositiontolerance	//in relative units
+	//2		fitfunctionlinewidth	//integer 1 - 10
+	//5		minfitsigma		//minimal sigma of the peaks to be fitted
+	//0.4		fithightthreshold	//
+	//................................................................
+
+	Bool_t	SetCalibrationParameters(const char* calparfile);
+	//Loads the file with calibration parameters
+	//
+	//  calparfile: file containing calibration parameters in format: crate number, address, subaddress, fA, fB, fC, fD
+	//
+	//	allowed comment characters: *, #, %, //
+
+	void	PrintInputParameters();
+	//I hope this is selfunderstanding function
+
+	void	PrintCalibrationParameters(const Int_t blockmin = 1, const Int_t blockmax = BLOCKSNUMBER - 1);
+	//Print calibration parameters fA, fB, fC, fD which are currently saved in object AculCalibration
+	//
+	//  blockmin: minimum  block data are displayed for
+	//  blockmax: maximum  block data are displayed for
+
+	Bool_t	CalculateCalibParameters(const char* inputfile, const char* block,
+			const Int_t address, const char* treename, Int_t lowerchannel = 0,
+			Int_t upperchannel = 4095, Int_t nEBins = 1000, Int_t lowersubaddress = 0,
+			Int_t uppersubaddress = ADDRESSNUMBER-1); //calculate calibration parameters for given block in given file
+	//function is not completely ready to use
+	//
+	//function for calculation of calibrate parameters for DAQ system based on "Go4"
+	//
+	//  inputfile: root file with calibration spectra
+	//  block: block name to be calibrated
+	//  lowerchannel: minimal channel from which the spectrum will be analysed
+	//  upperchannel: maximal channel up to which the spectrum will be analysed
+	//  lowersubaddress: block subaddress
+	//  uppersubaddress: block subbaddress
+
+	Bool_t	EnergyPositions(const char* inputfile, const char* block,
+			const Int_t address, const char* treename, Int_t lowerchannel = 0,
+			Int_t upperchannel = 4095, Int_t lowersubaddress = 0, Int_t uppersubaddress = ADDRESSNUMBER-1);
+
+	Int_t	PeaksFitting(TH1* hSpectrum, Option_t* option = "", Double_t sigmamin = 2);
+	//
+	//possible options: "V", "Q", ""
+
+	Int_t	SearchPeaks(const TH1 *hin, Double_t sigma = 2, Option_t *option = "", const Int_t searchedpeaks = 100);
+
+	void	FillRawSpectraFile(const char* rawdatafile, const char* block, const char* treename, TCanvas* rawCanvas = NULL, Option_t *option = "", Int_t xaxismin = 0, Int_t xaxismax = 4096);
+
+	void	ShowRawSpectra(const char* filename, const Int_t block, TCanvas* rawCanvas = NULL, Int_t xaxismin = 0, Int_t xaxismax = 4096, /*TObjArray* histList = NULL,*/ const Int_t subaddress = 16);
+	void	ShowSpectra(const char* filename, TCanvas* rawCanvas = NULL, Option_t *option = "", Int_t xaxismin = 0, Int_t xaxismax = 4096, /*TObjArray* histList = NULL,*/ const Int_t subaddress = 16);
+	void	ShowAnalyzedSpectra(const char* filename, TCanvas* fittedRawCanvas = NULL, Int_t xaxismin = 0, Int_t xaxismax = 4096, Int_t subaddress = 16);
+	//This function displays analyzed spectrum from a file, divides the canvas into a sufficient number of pads and displays
+	//spectrums of each  block subadress on the suitable pads or displays one  selected spectrum .
+	//Selects the peaks in the histogram and displays on the histogram how the spectrum were fitted.
+	//
+	//  filename: file .root containing analysed spectra
+	//  fittedRawCanvas: canvas on which one you will see the spectrum
+	//  xaxismin: Minimum channel, which will be displayed
+	//  xaxismax: Maximum channel, which will be displayed
+	//  subaddress:
+
+	void	ShowEnergySpectra(const char *filename, TCanvas* energyCanvas = NULL, const Int_t subaddress = 16, Option_t* option = "", Double_t xaxismin = 0., Double_t xaxismax = 10.); //option: "sum", "c", "+",
+	//Displays the spectrum  of the selected subbaddress block in MeV
+	//
+	//  filename: file .root containing calibrated spectra in MeV
+	//  energyCanvas: : canvas on which one you will see the spectrum
+	//  subaddress: block subaddress  which will be drawn
+	//  option: sum ,+ ,c
+	//  xaxismin: Minimum channel, which will be displayed
+	//  xaxismax: Maximum channel, which will be displayed
+
+	void DivideCanvas(TCanvas *c1, Int_t inputs);
+
+//	void
+
+	//dodelat funkce TTree* Get...(...) pro raw, anal i E spectra
+	Bool_t	AddCalFileToList(const char* calfilelist = "CalFileList.log");
+
+	void	ClearHistograms(Option_t* option = "");
+	void	DeleteStacks(Option_t* option = "");
+
+	void	MakeCalibrationFile(Char_t* calibrationfile, Char_t* calfilelist);
+
+	void	Reset();
+
+//private:
+
+	ClassDef(AculCalibration, 1);
+
+};

AculData/AculData.mk

+################################################################################
+# AculData input with some variables
+################################################################################
+
+ACULDATALIBS := -lCore -lCint -lRIO -lTree -lNet -lThread -lHist -lMatrix -lMathCore -lGpad -lGraf -lSpectrum
+
+# Add inputs and outputs from these tool invocations to the build variables 
+ACULDATA_HEADERS += \
+$(ACULDATA)/AculCalibration.h \
+$(ACULDATA)/ConfigDictionary.h \
+$(ACULDATA)/linkdef.h
+
+ACULDATACPP_SRCS += \
+$(ACULDATA)/AculCalibration.cpp \
+$(ACULDATA)/ConfigDictionary.cpp \
+$(ACULDATA)/AculDataCint.cpp
+
+ACULDATAOBJS += \
+$(ACULDATA)/AculCalibration.o \
+$(ACULDATA)/ConfigDictionary.o \
+$(ACULDATA)/AculDataCint.o
+
+ACULDATACPP_DEPS += \
+$(ACULDATA)/AculCalibration.d \
+$(ACULDATA)/ConfigDictionary.d \
+$(ACULDATA)/AculDataCint.d
\ No newline at end of file

AculData/AculDataCint.cpp

+//
+// File generated by rootcint at Wed Sep 28 16:51:40 2016
+
+// Do NOT change. Changes will be lost next time file is generated
+//
+
+#define R__DICTIONARY_FILENAME dIhomedIdariakdIUtilitiesdIAculDatadIAculDataCint
+#include "RConfig.h" //rootcint 4834
+#if !defined(R__ACCESS_IN_SYMBOL)
+//Break the privacy of classes -- Disabled for the moment
+#define private public
+#define protected public
+#endif
+
+// Since CINT ignores the std namespace, we need to do so in this file.
+namespace std {} using namespace std;
+#include "AculDataCint.h"
+
+#include "TCollectionProxyInfo.h"
+#include "TClass.h"
+#include "TBuffer.h"
+#include "TMemberInspector.h"
+#include "TError.h"
+
+#ifndef G__ROOT
+#define G__ROOT
+#endif
+
+#include "RtypesImp.h"
+#include "TIsAProxy.h"
+#include "TFileMergeInfo.h"
+
+// START OF SHADOWS
+
+namespace ROOT {
+   namespace Shadow {
+   } // of namespace Shadow
+} // of namespace ROOT
+// END OF SHADOWS
+
+namespace ROOT {
+   void AculCalibration_ShowMembers(void *obj, TMemberInspector &R__insp);
+   static void *new_AculCalibration(void *p = 0);
+   static void *newArray_AculCalibration(Long_t size, void *p);
+   static void delete_AculCalibration(void *p);
+   static void deleteArray_AculCalibration(void *p);
+   static void destruct_AculCalibration(void *p);
+   static void streamer_AculCalibration(TBuffer &buf, void *obj);
+
+   // Function generating the singleton type initializer
+   static TGenericClassInfo *GenerateInitInstanceLocal(const ::AculCalibration*)
+   {
+      ::AculCalibration *ptr = 0;
+      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::AculCalibration >(0);
+      static ::ROOT::TGenericClassInfo 
+         instance("AculCalibration", ::AculCalibration::Class_Version(), "/home/dariak/Utilities/AculData/AculCalibration.h", 37,
+                  typeid(::AculCalibration), DefineBehavior(ptr, ptr),
+                  &::AculCalibration::Dictionary, isa_proxy, 0,
+                  sizeof(::AculCalibration) );
+      instance.SetNew(&new_AculCalibration);
+      instance.SetNewArray(&newArray_AculCalibration);
+      instance.SetDelete(&delete_AculCalibration);
+      instance.SetDeleteArray(&deleteArray_AculCalibration);
+      instance.SetDestructor(&destruct_AculCalibration);
+      instance.SetStreamerFunc(&streamer_AculCalibration);
+      return &instance;
+   }
+   TGenericClassInfo *GenerateInitInstance(const ::AculCalibration*)
+   {
+      return GenerateInitInstanceLocal((::AculCalibration*)0);
+   }
+   // Static variable to force the class initialization
+   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::AculCalibration*)0x0); R__UseDummy(_R__UNIQUE_(Init));
+} // end of namespace ROOT
+
+namespace ROOT {
+   void ConfigDictionary_ShowMembers(void *obj, TMemberInspector &R__insp);
+   static void *new_ConfigDictionary(void *p = 0);
+   static void *newArray_ConfigDictionary(Long_t size, void *p);
+   static void delete_ConfigDictionary(void *p);
+   static void deleteArray_ConfigDictionary(void *p);
+   static void destruct_ConfigDictionary(void *p);
+   static void streamer_ConfigDictionary(TBuffer &buf, void *obj);
+
+   // Function generating the singleton type initializer
+   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ConfigDictionary*)
+   {
+      ::ConfigDictionary *ptr = 0;
+      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::ConfigDictionary >(0);
+      static ::ROOT::TGenericClassInfo 
+         instance("ConfigDictionary", ::ConfigDictionary::Class_Version(), "/home/dariak/Utilities/AculData/ConfigDictionary.h", 19,
+                  typeid(::ConfigDictionary), DefineBehavior(ptr, ptr),
+                  &::ConfigDictionary::Dictionary, isa_proxy, 0,
+                  sizeof(::ConfigDictionary) );
+      instance.SetNew(&new_ConfigDictionary);
+      instance.SetNewArray(&newArray_ConfigDictionary);
+      instance.SetDelete(&delete_ConfigDictionary);
+      instance.SetDeleteArray(&deleteArray_ConfigDictionary);
+      instance.SetDestructor(&destruct_ConfigDictionary);
+      instance.SetStreamerFunc(&streamer_ConfigDictionary);
+      return &instance;
+   }
+   TGenericClassInfo *GenerateInitInstance(const ::ConfigDictionary*)
+   {
+      return GenerateInitInstanceLocal((::ConfigDictionary*)0);
+   }
+   // Static variable to force the class initialization
+   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ConfigDictionary*)0x0); R__UseDummy(_R__UNIQUE_(Init));
+} // end of namespace ROOT
+
+//______________________________________________________________________________
+TClass *AculCalibration::fgIsA = 0;  // static to hold class pointer
+
+//______________________________________________________________________________
+const char *AculCalibration::Class_Name()
+{
+   return "AculCalibration";
+}
+
+//______________________________________________________________________________
+const char *AculCalibration::ImplFileName()
+{
+   return ::ROOT::GenerateInitInstanceLocal((const ::AculCalibration*)0x0)->GetImplFileName();
+}
+
+//______________________________________________________________________________
+int AculCalibration::ImplFileLine()
+{
+   return ::ROOT::GenerateInitInstanceLocal((const ::AculCalibration*)0x0)->GetImplFileLine();
+}
+
+//______________________________________________________________________________
+void AculCalibration::Dictionary()
+{
+   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::AculCalibration*)0x0)->GetClass();
+}
+
+//______________________________________________________________________________
+TClass *AculCalibration::Class()
+{
+   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::AculCalibration*)0x0)->GetClass();
+   return fgIsA;
+}
+
+//______________________________________________________________________________
+TClass *ConfigDictionary::fgIsA = 0;  // static to hold class pointer
+
+//______________________________________________________________________________
+const char *ConfigDictionary::Class_Name()
+{
+   return "ConfigDictionary";
+}
+
+//______________________________________________________________________________
+const char *ConfigDictionary::ImplFileName()
+{
+   return ::ROOT::GenerateInitInstanceLocal((const ::ConfigDictionary*)0x0)->GetImplFileName();
+}
+
+//______________________________________________________________________________
+int ConfigDictionary::ImplFileLine()
+{
+   return ::ROOT::GenerateInitInstanceLocal((const ::ConfigDictionary*)0x0)->GetImplFileLine();
+}
+
+//______________________________________________________________________________
+void ConfigDictionary::Dictionary()
+{
+   fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ConfigDictionary*)0x0)->GetClass();
+}
+
+//______________________________________________________________________________
+TClass *ConfigDictionary::Class()
+{
+   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::ConfigDictionary*)0x0)->GetClass();
+   return fgIsA;
+}
+
+//______________________________________________________________________________
+void AculCalibration::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class AculCalibration.
+
+   UInt_t R__s, R__c;
+   if (R__b.IsReading()) {
+      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
+      TObject::Streamer(R__b);
+      fHRawList.Streamer(R__b);
+      fHAnalyzedList.Streamer(R__b);
+      fHEnergyList.Streamer(R__b);
+      fHEnergyStack.Streamer(R__b);
+      R__b >> fCurrentHStack;
+      fCurrentHistList.Streamer(R__b);
+      R__b >> kRaNOPEAKS;
+      R__b.ReadStaticArray((double*)fEnergy);
+      R__b >> fLowerChannel;
+      R__b >> fUpperChannel;
+      R__b >> fLowerPeakRelativeHight;
+      R__b >> fUpperPeakRelativeHight;
+      R__b >> fPeakPositionTolerance;
+      R__b >> fFitFuncLineWidth;
+      R__b >> fFitMinSigma;
+      R__b >> fFitPeakThreshold;
+      R__b.ReadStaticArray((double*)fA);
+      R__b.ReadStaticArray((double*)fB);
+      R__b.ReadStaticArray((double*)fC);
+      R__b.ReadStaticArray((double*)fD);
+      R__b >> fCalInformation;
+      R__b.ReadStaticArray((double*)fPeak);
+      R__b.CheckByteCount(R__s, R__c, AculCalibration::IsA());
+   } else {
+      R__c = R__b.WriteVersion(AculCalibration::IsA(), kTRUE);
+      TObject::Streamer(R__b);
+      fHRawList.Streamer(R__b);
+      fHAnalyzedList.Streamer(R__b);
+      fHEnergyList.Streamer(R__b);
+      fHEnergyStack.Streamer(R__b);
+      R__b << fCurrentHStack;
+      fCurrentHistList.Streamer(R__b);
+      R__b << kRaNOPEAKS;
+      R__b.WriteArray(fEnergy, 20);
+      R__b << fLowerChannel;
+      R__b << fUpperChannel;
+      R__b << fLowerPeakRelativeHight;
+      R__b << fUpperPeakRelativeHight;
+      R__b << fPeakPositionTolerance;
+      R__b << fFitFuncLineWidth;
+      R__b << fFitMinSigma;
+      R__b << fFitPeakThreshold;
+      R__b.WriteArray((double*)fA, 3200);
+      R__b.WriteArray((double*)fB, 3200);
+      R__b.WriteArray((double*)fC, 3200);
+      R__b.WriteArray((double*)fD, 3200);
+      R__b << fCalInformation;
+      R__b.WriteArray(fPeak, 20);
+      R__b.SetByteCount(R__c, kTRUE);
+   }
+}
+
+//______________________________________________________________________________
+void AculCalibration::ShowMembers(TMemberInspector &R__insp)
+{
+      // Inspect the data members of an object of class AculCalibration.
+      TClass *R__cl = ::AculCalibration::IsA();
+      if (R__cl || R__insp.IsA()) { }
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHRawList", &fHRawList);
+      R__insp.InspectMember(fHRawList, "fHRawList.");
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHAnalyzedList", &fHAnalyzedList);
+      R__insp.InspectMember(fHAnalyzedList, "fHAnalyzedList.");
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHEnergyList", &fHEnergyList);
+      R__insp.InspectMember(fHEnergyList, "fHEnergyList.");
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHEnergyStack", &fHEnergyStack);
+      R__insp.InspectMember(fHEnergyStack, "fHEnergyStack.");
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentHStack", &fCurrentHStack);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentHistList", &fCurrentHistList);
+      R__insp.InspectMember(fCurrentHistList, "fCurrentHistList.");
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "kRaNOPEAKS", &kRaNOPEAKS);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnergy[20]", fEnergy);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerChannel", &fLowerChannel);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperChannel", &fUpperChannel);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerPeakRelativeHight", &fLowerPeakRelativeHight);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperPeakRelativeHight", &fUpperPeakRelativeHight);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeakPositionTolerance", &fPeakPositionTolerance);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitFuncLineWidth", &fFitFuncLineWidth);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitMinSigma", &fFitMinSigma);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitPeakThreshold", &fFitPeakThreshold);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fA[100][32]", fA);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fB[100][32]", fB);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fC[100][32]", fC);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fD[100][32]", fD);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCalInformation", &fCalInformation);
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeak[20]", fPeak);
+      TObject::ShowMembers(R__insp);
+}
+
+namespace ROOT {
+   // Wrappers around operator new
+   static void *new_AculCalibration(void *p) {
+      return  p ? new(p) ::AculCalibration : new ::AculCalibration;
+   }
+   static void *newArray_AculCalibration(Long_t nElements, void *p) {
+      return p ? new(p) ::AculCalibration[nElements] : new ::AculCalibration[nElements];
+   }
+   // Wrapper around operator delete
+   static void delete_AculCalibration(void *p) {
+      delete ((::AculCalibration*)p);
+   }
+   static void deleteArray_AculCalibration(void *p) {
+      delete [] ((::AculCalibration*)p);
+   }
+   static void destruct_AculCalibration(void *p) {
+      typedef ::AculCalibration current_t;
+      ((current_t*)p)->~current_t();
+   }
+   // Wrapper around a custom streamer member function.
+   static void streamer_AculCalibration(TBuffer &buf, void *obj) {
+      ((::AculCalibration*)obj)->::AculCalibration::Streamer(buf);
+   }
+} // end of namespace ROOT for class ::AculCalibration
+
+//______________________________________________________________________________
+void ConfigDictionary::Streamer(TBuffer &R__b)
+{
+   // Stream an object of class ConfigDictionary.
+
+   UInt_t R__s, R__c;
+   if (R__b.IsReading()) {
+      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
+      {
+         map<std::string,std::string> &R__stl =  configMap;
+         R__stl.clear();
+         int R__i, R__n;
+         R__b >> R__n;
+         for (R__i = 0; R__i < R__n; R__i++) {
+            string R__t;
+            {TString R__str;
+             R__str.Streamer(R__b);
+             R__t = R__str.Data();}
+            string R__t2;
+            {TString R__str;
+             R__str.Streamer(R__b);
+             R__t2 = R__str.Data();}
+            typedef string Value_t;
+            std::pair<Value_t const, string > R__t3(R__t,R__t2);
+            R__stl.insert(R__t3);
+         }
+      }
+      R__b.CheckByteCount(R__s, R__c, ConfigDictionary::IsA());
+   } else {
+      R__c = R__b.WriteVersion(ConfigDictionary::IsA(), kTRUE);
+      {
+         map<std::string,std::string> &R__stl =  configMap;
+         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
+         R__b << R__n;
+         if(R__n) {
+            map<std::string,std::string>::iterator R__k;
+            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
+            {TString R__str(((*R__k).first ).c_str());
+             R__str.Streamer(R__b);};
+            {TString R__str(((*R__k).second).c_str());
+             R__str.Streamer(R__b);};
+            }
+         }
+      }
+      R__b.SetByteCount(R__c, kTRUE);
+   }
+}
+
+//______________________________________________________________________________
+void ConfigDictionary::ShowMembers(TMemberInspector &R__insp)
+{
+      // Inspect the data members of an object of class ConfigDictionary.
+      TClass *R__cl = ::ConfigDictionary::IsA();
+      if (R__cl || R__insp.IsA()) { }
+      R__insp.Inspect(R__cl, R__insp.GetParent(), "configMap", (void*)&configMap);
+      R__insp.InspectMember("map<std::string,std::string>", (void*)&configMap, "configMap.", false);
+}
+
+namespace ROOT {
+   // Wrappers around operator new
+   static void *new_ConfigDictionary(void *p) {
+      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ConfigDictionary : new ::ConfigDictionary;
+   }
+   static void *newArray_ConfigDictionary(Long_t nElements, void *p) {
+      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ConfigDictionary[nElements] : new ::ConfigDictionary[nElements];
+   }
+   // Wrapper around operator delete
+   static void delete_ConfigDictionary(void *p) {
+      delete ((::ConfigDictionary*)p);
+   }
+   static void deleteArray_ConfigDictionary(void *p) {
+      delete [] ((::ConfigDictionary*)p);
+   }
+   static void destruct_ConfigDictionary(void *p) {
+      typedef ::ConfigDictionary current_t;
+      ((current_t*)p)->~current_t();
+   }
+   // Wrapper around a custom streamer member function.
+   static void streamer_ConfigDictionary(TBuffer &buf, void *obj) {
+      ((::ConfigDictionary*)obj)->::ConfigDictionary::Streamer(buf);
+   }
+} // end of namespace ROOT for class ::ConfigDictionary
+
+namespace ROOT {
+   void maplEstringcOstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
+   static void maplEstringcOstringgR_Dictionary();
+   static void *new_maplEstringcOstringgR(void *p = 0);
+   static void *newArray_maplEstringcOstringgR(Long_t size, void *p);
+   static void delete_maplEstringcOstringgR(void *p);
+   static void deleteArray_maplEstringcOstringgR(void *p);
+   static void destruct_maplEstringcOstringgR(void *p);
+
+   // Function generating the singleton type initializer
+   static TGenericClassInfo *GenerateInitInstanceLocal(const map<string,string>*)
+   {
+      map<string,string> *ptr = 0;
+      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<string,string>),0);
+      static ::ROOT::TGenericClassInfo 
+         instance("map<string,string>", -2, "/usr/local/lib64/root/5.30/lib/cint/cint/lib/prec_stl/map", 63,
+                  typeid(map<string,string>), DefineBehavior(ptr, ptr),
+                  0, &maplEstringcOstringgR_Dictionary, isa_proxy, 0,
+                  sizeof(map<string,string>) );
+      instance.SetNew(&new_maplEstringcOstringgR);
+      instance.SetNewArray(&newArray_maplEstringcOstringgR);
+      instance.SetDelete(&delete_maplEstringcOstringgR);
+      instance.SetDeleteArray(&deleteArray_maplEstringcOstringgR);
+      instance.SetDestructor(&destruct_maplEstringcOstringgR);
+      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<string,string> >()));
+      return &instance;
+   }
+   // Static variable to force the class initialization
+   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<string,string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
+
+   // Dictionary for non-ClassDef classes
+   static void maplEstringcOstringgR_Dictionary() {
+      ::ROOT::GenerateInitInstanceLocal((const map<string,string>*)0x0)->GetClass();
+   }
+
+} // end of namespace ROOT
+
+namespace ROOT {
+   // Wrappers around operator new
+   static void *new_maplEstringcOstringgR(void *p) {
+      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,string> : new map<string,string>;
+   }
+   static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) {
+      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<string,string>[nElements] : new map<string,string>[nElements];
+   }
+   // Wrapper around operator delete
+   static void delete_maplEstringcOstringgR(void *p) {
+      delete ((map<string,string>*)p);
+   }
+   static void deleteArray_maplEstringcOstringgR(void *p) {
+      delete [] ((map<string,string>*)p);
+   }
+   static void destruct_maplEstringcOstringgR(void *p) {
+      typedef map<string,string> current_t;
+      ((current_t*)p)->~current_t();
+   }
+} // end of namespace ROOT for class map<string,string>
+
+/********************************************************
+* /home/dariak/Utilities/AculData/AculDataCint.cpp
+* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
+*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
+*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
+********************************************************/
+
+#ifdef G__MEMTEST
+#undef malloc
+#undef free
+#endif
+
+#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
+#pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif
+
+extern "C" void G__cpp_reset_tagtableAculDataCint();
+
+extern "C" void G__set_cpp_environmentAculDataCint() {
+  G__cpp_reset_tagtableAculDataCint();
+}
+#include <new>
+extern "C" int G__cpp_dllrevAculDataCint() { return(30051515); }
+
+/*********************************************************
+* Member function Interface Method
+*********************************************************/
+
+/* AculCalibration */
+static int G__AculDataCint_620_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   AculCalibration* p = NULL;
+   char* gvp = (char*) G__getgvp();
+   int n = G__getaryconstruct();
+   if (n) {
+     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
+       p = new AculCalibration[n];
+     } else {
+       p = new((void*) gvp) AculCalibration[n];
+     }
+   } else {
+     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
+       p = new AculCalibration;
+     } else {
+       p = new((void*) gvp) AculCalibration;
+     }
+   }
+   result7->obj.i = (long) p;
+   result7->ref = (long) p;
+   G__set_tagnum(result7,G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   AculCalibration* p = NULL;
+   char* gvp = (char*) G__getgvp();
+   //m: 1
+   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
+     p = new AculCalibration((const char*) G__int(libp->para[0]));
+   } else {
+     p = new((void*) gvp) AculCalibration((const char*) G__int(libp->para[0]));
+   }
+   result7->obj.i = (long) p;
+   result7->ref = (long) p;
+   G__set_tagnum(result7,G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 1:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->SetInputParameters((const char*) G__int(libp->para[0])));
+      break;
+   case 0:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->SetInputParameters());
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->SetCalibrationParameters((const char*) G__int(libp->para[0])));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((AculCalibration*) G__getstructoffset())->PrintInputParameters();
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 2:
+      ((AculCalibration*) G__getstructoffset())->PrintCalibrationParameters((const Int_t) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
+      G__setnull(result7);
+      break;
+   case 1:
+      ((AculCalibration*) G__getstructoffset())->PrintCalibrationParameters((const Int_t) G__int(libp->para[0]));
+      G__setnull(result7);
+      break;
+   case 0:
+      ((AculCalibration*) G__getstructoffset())->PrintCalibrationParameters();
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 9:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->CalculateCalibParameters(
+(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
+, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])
+, (Int_t) G__int(libp->para[8])));
+      break;
+   case 8:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->CalculateCalibParameters(
+(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
+, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])));
+      break;
+   case 7:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->CalculateCalibParameters(
+(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
+, (Int_t) G__int(libp->para[6])));
+      break;
+   case 6:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->CalculateCalibParameters((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
+      break;
+   case 5:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->CalculateCalibParameters((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4])));
+      break;
+   case 4:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->CalculateCalibParameters((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 8:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->EnergyPositions(
+(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
+, (Int_t) G__int(libp->para[6]), (Int_t) G__int(libp->para[7])));
+      break;
+   case 7:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->EnergyPositions(
+(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
+, (Int_t) G__int(libp->para[6])));
+      break;
+   case 6:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->EnergyPositions((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])));
+      break;
+   case 5:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->EnergyPositions((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4])));
+      break;
+   case 4:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->EnergyPositions((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 3:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->PeaksFitting((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
+, (Double_t) G__double(libp->para[2])));
+      break;
+   case 2:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->PeaksFitting((TH1*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
+      break;
+   case 1:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->PeaksFitting((TH1*) G__int(libp->para[0])));
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 4:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->SearchPeaks((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
+, (Option_t*) G__int(libp->para[2]), (const Int_t) G__int(libp->para[3])));
+      break;
+   case 3:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->SearchPeaks((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
+, (Option_t*) G__int(libp->para[2])));
+      break;
+   case 2:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->SearchPeaks((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
+      break;
+   case 1:
+      G__letint(result7, 105, (long) ((AculCalibration*) G__getstructoffset())->SearchPeaks((TH1*) G__int(libp->para[0])));
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 7:
+      ((AculCalibration*) G__getstructoffset())->FillRawSpectraFile(
+(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const char*) G__int(libp->para[2]), (TCanvas*) G__int(libp->para[3])
+, (Option_t*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
+, (Int_t) G__int(libp->para[6]));
+      G__setnull(result7);
+      break;
+   case 6:
+      ((AculCalibration*) G__getstructoffset())->FillRawSpectraFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const char*) G__int(libp->para[2]), (TCanvas*) G__int(libp->para[3])
+, (Option_t*) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
+      G__setnull(result7);
+      break;
+   case 5:
+      ((AculCalibration*) G__getstructoffset())->FillRawSpectraFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const char*) G__int(libp->para[2]), (TCanvas*) G__int(libp->para[3])
+, (Option_t*) G__int(libp->para[4]));
+      G__setnull(result7);
+      break;
+   case 4:
+      ((AculCalibration*) G__getstructoffset())->FillRawSpectraFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const char*) G__int(libp->para[2]), (TCanvas*) G__int(libp->para[3]));
+      G__setnull(result7);
+      break;
+   case 3:
+      ((AculCalibration*) G__getstructoffset())->FillRawSpectraFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
+, (const char*) G__int(libp->para[2]));
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 6:
+      ((AculCalibration*) G__getstructoffset())->ShowRawSpectra((const char*) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])
+, (TCanvas*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5]));
+      G__setnull(result7);
+      break;
+   case 5:
+      ((AculCalibration*) G__getstructoffset())->ShowRawSpectra((const char*) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])
+, (TCanvas*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]));
+      G__setnull(result7);
+      break;
+   case 4:
+      ((AculCalibration*) G__getstructoffset())->ShowRawSpectra((const char*) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])
+, (TCanvas*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
+      G__setnull(result7);
+      break;
+   case 3:
+      ((AculCalibration*) G__getstructoffset())->ShowRawSpectra((const char*) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1])
+, (TCanvas*) G__int(libp->para[2]));
+      G__setnull(result7);
+      break;
+   case 2:
+      ((AculCalibration*) G__getstructoffset())->ShowRawSpectra((const char*) G__int(libp->para[0]), (const Int_t) G__int(libp->para[1]));
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 6:
+      ((AculCalibration*) G__getstructoffset())->ShowSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Option_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]), (const Int_t) G__int(libp->para[5]));
+      G__setnull(result7);
+      break;
+   case 5:
+      ((AculCalibration*) G__getstructoffset())->ShowSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Option_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]));
+      G__setnull(result7);
+      break;
+   case 4:
+      ((AculCalibration*) G__getstructoffset())->ShowSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Option_t*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
+      G__setnull(result7);
+      break;
+   case 3:
+      ((AculCalibration*) G__getstructoffset())->ShowSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Option_t*) G__int(libp->para[2]));
+      G__setnull(result7);
+      break;
+   case 2:
+      ((AculCalibration*) G__getstructoffset())->ShowSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1]));
+      G__setnull(result7);
+      break;
+   case 1:
+      ((AculCalibration*) G__getstructoffset())->ShowSpectra((const char*) G__int(libp->para[0]));
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 5:
+      ((AculCalibration*) G__getstructoffset())->ShowAnalyzedSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
+, (Int_t) G__int(libp->para[4]));
+      G__setnull(result7);
+      break;
+   case 4:
+      ((AculCalibration*) G__getstructoffset())->ShowAnalyzedSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
+      G__setnull(result7);
+      break;
+   case 3:
+      ((AculCalibration*) G__getstructoffset())->ShowAnalyzedSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (Int_t) G__int(libp->para[2]));
+      G__setnull(result7);
+      break;
+   case 2:
+      ((AculCalibration*) G__getstructoffset())->ShowAnalyzedSpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1]));
+      G__setnull(result7);
+      break;
+   case 1:
+      ((AculCalibration*) G__getstructoffset())->ShowAnalyzedSpectra((const char*) G__int(libp->para[0]));
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 6:
+      ((AculCalibration*) G__getstructoffset())->ShowEnergySpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
+, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
+      G__setnull(result7);
+      break;
+   case 5:
+      ((AculCalibration*) G__getstructoffset())->ShowEnergySpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
+, (Double_t) G__double(libp->para[4]));
+      G__setnull(result7);
+      break;
+   case 4:
+      ((AculCalibration*) G__getstructoffset())->ShowEnergySpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3]));
+      G__setnull(result7);
+      break;
+   case 3:
+      ((AculCalibration*) G__getstructoffset())->ShowEnergySpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1])
+, (const Int_t) G__int(libp->para[2]));
+      G__setnull(result7);
+      break;
+   case 2:
+      ((AculCalibration*) G__getstructoffset())->ShowEnergySpectra((const char*) G__int(libp->para[0]), (TCanvas*) G__int(libp->para[1]));
+      G__setnull(result7);
+      break;
+   case 1:
+      ((AculCalibration*) G__getstructoffset())->ShowEnergySpectra((const char*) G__int(libp->para[0]));
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((AculCalibration*) G__getstructoffset())->DivideCanvas((TCanvas*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 1:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->AddCalFileToList((const char*) G__int(libp->para[0])));
+      break;
+   case 0:
+      G__letint(result7, 103, (long) ((AculCalibration*) G__getstructoffset())->AddCalFileToList());
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 1:
+      ((AculCalibration*) G__getstructoffset())->ClearHistograms((Option_t*) G__int(libp->para[0]));
+      G__setnull(result7);
+      break;
+   case 0:
+      ((AculCalibration*) G__getstructoffset())->ClearHistograms();
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   switch (libp->paran) {
+   case 1:
+      ((AculCalibration*) G__getstructoffset())->DeleteStacks((Option_t*) G__int(libp->para[0]));
+      G__setnull(result7);
+      break;
+   case 0:
+      ((AculCalibration*) G__getstructoffset())->DeleteStacks();
+      G__setnull(result7);
+      break;
+   }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((AculCalibration*) G__getstructoffset())->MakeCalibrationFile((Char_t*) G__int(libp->para[0]), (Char_t*) G__int(libp->para[1]));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((AculCalibration*) G__getstructoffset())->Reset();
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 85, (long) AculCalibration::Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 67, (long) AculCalibration::Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 115, (long) AculCalibration::Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      AculCalibration::Dictionary();
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((AculCalibration*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 67, (long) AculCalibration::DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 105, (long) AculCalibration::ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 67, (long) AculCalibration::ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_620_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 105, (long) AculCalibration::DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef AculCalibration G__TAculCalibration;
+static int G__AculDataCint_620_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   char* gvp = (char*) G__getgvp();
+   long soff = G__getstructoffset();
+   int n = G__getaryconstruct();
+   //
+   //has_a_delete: 1
+   //has_own_delete1arg: 0
+   //has_own_delete2arg: 0
+   //
+   if (!soff) {
+     return(1);
+   }
+   if (n) {
+     if (gvp == (char*)G__PVOID) {
+       delete[] (AculCalibration*) soff;
+     } else {
+       G__setgvp((long) G__PVOID);
+       for (int i = n - 1; i >= 0; --i) {
+         ((AculCalibration*) (soff+(sizeof(AculCalibration)*i)))->~G__TAculCalibration();
+       }
+       G__setgvp((long)gvp);
+     }
+   } else {
+     if (gvp == (char*)G__PVOID) {
+       delete (AculCalibration*) soff;
+     } else {
+       G__setgvp((long) G__PVOID);
+       ((AculCalibration*) (soff))->~G__TAculCalibration();
+       G__setgvp((long)gvp);
+     }
+   }
+   G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* ConfigDictionary */
+static int G__AculDataCint_671_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   ConfigDictionary* p = NULL;
+   char* gvp = (char*) G__getgvp();
+   int n = G__getaryconstruct();
+   if (n) {
+     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
+       p = new ConfigDictionary[n];
+     } else {
+       p = new((void*) gvp) ConfigDictionary[n];
+     }
+   } else {
+     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
+       p = new ConfigDictionary;
+     } else {
+       p = new((void*) gvp) ConfigDictionary;
+     }
+   }
+   result7->obj.i = (long) p;
+   result7->ref = (long) p;
+   G__set_tagnum(result7,G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   ConfigDictionary* p = NULL;
+   char* gvp = (char*) G__getgvp();
+   //m: 1
+   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
+     p = new ConfigDictionary(*((string*) G__int(libp->para[0])));
+   } else {
+     p = new((void*) gvp) ConfigDictionary(*((string*) G__int(libp->para[0])));
+   }
+   result7->obj.i = (long) p;
+   result7->ref = (long) p;
+   G__set_tagnum(result7,G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 85, (long) ConfigDictionary::Class());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 67, (long) ConfigDictionary::Class_Name());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 115, (long) ConfigDictionary::Class_Version());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ConfigDictionary::Dictionary();
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 85, (long) ((const ConfigDictionary*) G__getstructoffset())->IsA());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 67, (long) ConfigDictionary::DeclFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 105, (long) ConfigDictionary::ImplFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 67, (long) ConfigDictionary::ImplFileName());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 105, (long) ConfigDictionary::DeclFileLine());
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      {
+         string* pobj;
+         string xobj = ((ConfigDictionary*) G__getstructoffset())->ToString();
+         pobj = new string(xobj);
+         result7->obj.i = (long) ((void*) pobj);
+         result7->ref = result7->obj.i;
+         G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->FromString(*((string*) G__int(libp->para[0])));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      {
+         string* pobj;
+         string xobj = ((ConfigDictionary*) G__getstructoffset())->GetString(*((string*) G__int(libp->para[0])));
+         pobj = new string(xobj);
+         result7->obj.i = (long) ((void*) pobj);
+         result7->ref = result7->obj.i;
+         G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 105, (long) ((ConfigDictionary*) G__getstructoffset())->GetInt(*((string*) G__int(libp->para[0]))));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letdouble(result7, 100, (double) ((ConfigDictionary*) G__getstructoffset())->GetDouble(*((string*) G__int(libp->para[0]))));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      G__letint(result7, 103, (long) ((ConfigDictionary*) G__getstructoffset())->GetBool(*((string*) G__int(libp->para[0]))));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->SetString(*((string*) G__int(libp->para[0])), *((string*) G__int(libp->para[1])));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->SetDouble(*((string*) G__int(libp->para[0])), (double) G__double(libp->para[1]));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->SetInt(*((string*) G__int(libp->para[0])), (int) G__int(libp->para[1]));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      ((ConfigDictionary*) G__getstructoffset())->SetBool(*((string*) G__int(libp->para[0])), (bool) G__int(libp->para[1]));
+      G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      {
+         ConfigDictionary::CDIter* pobj;
+         ConfigDictionary::CDIter xobj = ((ConfigDictionary*) G__getstructoffset())->Begin();
+         pobj = new ConfigDictionary::CDIter(xobj);
+         result7->obj.i = (long) ((void*) pobj);
+         result7->ref = result7->obj.i;
+         G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+static int G__AculDataCint_671_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+      {
+         ConfigDictionary::CDIter* pobj;
+         ConfigDictionary::CDIter xobj = ((ConfigDictionary*) G__getstructoffset())->End();
+         pobj = new ConfigDictionary::CDIter(xobj);
+         result7->obj.i = (long) ((void*) pobj);
+         result7->ref = result7->obj.i;
+         G__store_tempobject(*result7);
+      }
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic copy constructor
+static int G__AculDataCint_671_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+
+{
+   ConfigDictionary* p;
+   void* tmp = (void*) G__int(libp->para[0]);
+   p = new ConfigDictionary(*(ConfigDictionary*) tmp);
+   result7->obj.i = (long) p;
+   result7->ref = (long) p;
+   G__set_tagnum(result7,G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary));
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic destructor
+typedef ConfigDictionary G__TConfigDictionary;
+static int G__AculDataCint_671_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   char* gvp = (char*) G__getgvp();
+   long soff = G__getstructoffset();
+   int n = G__getaryconstruct();
+   //
+   //has_a_delete: 0
+   //has_own_delete1arg: 0
+   //has_own_delete2arg: 0
+   //
+   if (!soff) {
+     return(1);
+   }
+   if (n) {
+     if (gvp == (char*)G__PVOID) {
+       delete[] (ConfigDictionary*) soff;
+     } else {
+       G__setgvp((long) G__PVOID);
+       for (int i = n - 1; i >= 0; --i) {
+         ((ConfigDictionary*) (soff+(sizeof(ConfigDictionary)*i)))->~G__TConfigDictionary();
+       }
+       G__setgvp((long)gvp);
+     }
+   } else {
+     if (gvp == (char*)G__PVOID) {
+       delete (ConfigDictionary*) soff;
+     } else {
+       G__setgvp((long) G__PVOID);
+       ((ConfigDictionary*) (soff))->~G__TConfigDictionary();
+       G__setgvp((long)gvp);
+     }
+   }
+   G__setnull(result7);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+// automatic assignment operator
+static int G__AculDataCint_671_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
+{
+   ConfigDictionary* dest = (ConfigDictionary*) G__getstructoffset();
+   *dest = *(ConfigDictionary*) libp->para[0].ref;
+   const ConfigDictionary& obj = *dest;
+   result7->ref = (long) (&obj);
+   result7->obj.i = (long) (&obj);
+   return(1 || funcname || hash || result7 || libp) ;
+}
+
+
+/* Setting up global function */
+
+/*********************************************************
+* Member function Stub
+*********************************************************/
+
+/* AculCalibration */
+
+/* ConfigDictionary */
+
+/*********************************************************
+* Global function Stub
+*********************************************************/
+
+/*********************************************************
+* Get size of pointer to member function
+*********************************************************/
+class G__Sizep2memfuncAculDataCint {
+ public:
+  G__Sizep2memfuncAculDataCint(): p(&G__Sizep2memfuncAculDataCint::sizep2memfunc) {}
+    size_t sizep2memfunc() { return(sizeof(p)); }
+  private:
+    size_t (G__Sizep2memfuncAculDataCint::*p)();
+};
+
+size_t G__get_sizep2memfuncAculDataCint()
+{
+  G__Sizep2memfuncAculDataCint a;
+  G__setsizep2memfunc((int)a.sizep2memfunc());
+  return((size_t)a.sizep2memfunc());
+}
+
+
+/*********************************************************
+* virtual base class offset calculation interface
+*********************************************************/
+
+   /* Setting up class inheritance */
+
+/*********************************************************
+* Inheritance information setup/
+*********************************************************/
+extern "C" void G__cpp_setup_inheritanceAculDataCint() {
+
+   /* Setting up class inheritance */
+   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration))) {
+     AculCalibration *G__Lderived;
+     G__Lderived=(AculCalibration*)0x1000;
+     {
+       TObject *G__Lpbase=(TObject*)G__Lderived;
+       G__inheritance_setup(G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration),G__get_linked_tagnum(&G__AculDataCintLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
+     }
+   }
+}
+
+/*********************************************************
+* typedef information setup/
+*********************************************************/
+extern "C" void G__cpp_setup_typetableAculDataCint() {
+
+   /* Setting up typedef entry */
+   G__search_typename2("Char_t",99,-1,0,-1);
+   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
+   G__search_typename2("Int_t",105,-1,0,-1);
+   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
+   G__search_typename2("Double_t",100,-1,0,-1);
+   G__setnewtype(-1,"Double 8 bytes",0);
+   G__search_typename2("Bool_t",103,-1,0,-1);
+   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
+   G__search_typename2("Version_t",115,-1,0,-1);
+   G__setnewtype(-1,"Class version identifier (short)",0);
+   G__search_typename2("Option_t",99,-1,256,-1);
+   G__setnewtype(-1,"Option string (const char)",0);
+   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TVectorTlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TVectorTlEdoublegR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTBaselEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTBaselEdoublegR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTRow_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTColumn_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTDiag_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTFlat_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSub_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTRowlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTColumnlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTDiaglEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTFlatlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSublEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseRowlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TElementActionTlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__AculDataCintLN_TElementPosActionTlEfloatgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("map<std::string,std::string>",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("map<string,string>",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("map<string,string,less<string> >",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1);
+   G__setnewtype(-1,NULL,0);
+   G__search_typename2("CDIter",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary));
+   G__setnewtype(-1,NULL,0);
+}
+
+/*********************************************************
+* Data Member information setup/
+*********************************************************/
+
+   /* Setting up class,struct,union tag member variable */
+
+   /* AculCalibration */
+static void G__setup_memvarAculCalibration(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration));
+   { AculCalibration *p; p=(AculCalibration*)0x1000; if (p) { }
+   G__memvar_setup((void*)((long)(&p->fHRawList)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TObjArray),-1,-1,1,"fHRawList=",0,"list of raw histograms, list is set to owner");
+   G__memvar_setup((void*)((long)(&p->fHAnalyzedList)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TObjArray),-1,-1,1,"fHAnalyzedList=",0,"list of fitted and analyzed histograms, list is set to owner");
+   G__memvar_setup((void*)((long)(&p->fHEnergyList)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TObjArray),-1,-1,1,"fHEnergyList=",0,"list of calibrated histograms, list is set to owner");
+   G__memvar_setup((void*)((long)(&p->fHEnergyStack)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__AculDataCintLN_THStack),-1,-1,1,"fHEnergyStack=",0,"some stack");
+   G__memvar_setup((void*)((long)(&p->fCurrentHStack)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__AculDataCintLN_THStack),-1,-1,1,"fCurrentHStack=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->fCurrentHistList)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TObjArray),-1,-1,1,"fCurrentHistList=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->kRaNOPEAKS)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"kRaNOPEAKS=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->fEnergy)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fEnergy[20]=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->fLowerChannel)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fLowerChannel=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->fUpperChannel)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fUpperChannel=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->fLowerPeakRelativeHight)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fLowerPeakRelativeHight=",0,"pouziva se, private");
+   G__memvar_setup((void*)((long)(&p->fUpperPeakRelativeHight)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fUpperPeakRelativeHight=",0,"pouziva se, private, nastavit nenulovou prednastavenou hodnotu");
+   G__memvar_setup((void*)((long)(&p->fPeakPositionTolerance)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPeakPositionTolerance=",0,"pouziva se, private");
+   G__memvar_setup((void*)((long)(&p->fFitFuncLineWidth)-(long)(p)),115,0,0,-1,G__defined_typename("Width_t"),-1,1,"fFitFuncLineWidth=",0,"private");
+   G__memvar_setup((void*)((long)(&p->fFitMinSigma)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fFitMinSigma=",0,"pouziva se, private");
+   G__memvar_setup((void*)((long)(&p->fFitPeakThreshold)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fFitPeakThreshold=",0,"pouziva se, private, prozkoumat, k cemu vlastne slouzi ve fci ShowPeaks, popremyslet o vhodnem prednastaveni v konstruktoru");
+   G__memvar_setup((void*)((long)(&p->fA)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fA[100][32]=",0,"kalibracni parametry, f(x) = fA*x + fB");
+   G__memvar_setup((void*)((long)(&p->fB)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fB[100][32]=",0,"kalibracni parametry, f(x) = fA*x + fB");
+   G__memvar_setup((void*)((long)(&p->fC)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fC[100][32]=",0,"treti kalibracni parametr, jine zavislosti nez pol1");
+   G__memvar_setup((void*)((long)(&p->fD)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fD[100][32]=",0,"ctvrty kalibracni parametr");
+   G__memvar_setup((void*)((long)(&p->fCalInformation)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TFile),-1,-1,1,"fCalInformation=",0,(char*)NULL);
+   G__memvar_setup((void*)((long)(&p->fPeak)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fPeak[20]=",0,"v teto promenne je ulozena momentalni hodnota piku v kanalech, zejmena v jedne fci, mozno udelat ji jako lokalni, bude navratovou hodnotou fce PeaksFitting, predelat delku pole");
+   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+
+   /* ConfigDictionary */
+static void G__setup_memvarConfigDictionary(void) {
+   G__tag_memvar_setup(G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary));
+   { ConfigDictionary *p; p=(ConfigDictionary*)0x1000; if (p) { }
+   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
+   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__AculDataCintLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
+   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),G__defined_typename("map<std::string,std::string>"),-1,4,"configMap=",0,(char*)NULL);
+   }
+   G__tag_memvar_reset();
+}
+
+extern "C" void G__cpp_setup_memvarAculDataCint() {
+}
+/***********************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+************************************************************
+***********************************************************/
+
+/*********************************************************
+* Member function information setup for each class
+*********************************************************/
+static void G__setup_memfuncAculCalibration(void) {
+   /* AculCalibration */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration));
+   G__memfunc_setup("AculCalibration",1517,G__AculDataCint_620_0_1, 105, G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("AculCalibration",1517,G__AculDataCint_620_0_2, 105, G__get_linked_tagnum(&G__AculDataCintLN_AculCalibration), -1, 0, 1, 1, 1, 0, "C - - 10 - parfile", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SetInputParameters",1872,G__AculDataCint_620_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"parforcal.par\"' inputparfile", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SetCalibrationParameters",2472,G__AculDataCint_620_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - calparfile", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("PrintInputParameters",2097,G__AculDataCint_620_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("PrintCalibrationParameters",2697,G__AculDataCint_620_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
+"i - 'Int_t' 10 '1' blockmin i - 'Int_t' 10 '100-1' blockmax", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("CalculateCalibParameters",2429,G__AculDataCint_620_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 9, 1, 1, 0, 
+"C - - 10 - inputfile C - - 10 - block "
+"i - 'Int_t' 10 - address C - - 10 - treename "
+"i - 'Int_t' 0 '0' lowerchannel i - 'Int_t' 0 '4095' upperchannel "
+"i - 'Int_t' 0 '1000' nEBins i - 'Int_t' 0 '0' lowersubaddress "
+"i - 'Int_t' 0 '32-1' uppersubaddress", "calculate calibration parameters for given block in given file", (void*) NULL, 0);
+   G__memfunc_setup("EnergyPositions",1586,G__AculDataCint_620_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 8, 1, 1, 0, 
+"C - - 10 - inputfile C - - 10 - block "
+"i - 'Int_t' 10 - address C - - 10 - treename "
+"i - 'Int_t' 0 '0' lowerchannel i - 'Int_t' 0 '4095' upperchannel "
+"i - 'Int_t' 0 '0' lowersubaddress i - 'Int_t' 0 '32-1' uppersubaddress", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("PeaksFitting",1225,G__AculDataCint_620_0_9, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
+"U 'TH1' - 0 - hSpectrum C - 'Option_t' 10 '\"\"' option "
+"d - 'Double_t' 0 '2' sigmamin", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SearchPeaks",1098,G__AculDataCint_620_0_10, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
+"U 'TH1' - 10 - hin d - 'Double_t' 0 '2' sigma "
+"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 10 '100' searchedpeaks", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("FillRawSpectraFile",1795,G__AculDataCint_620_0_11, 121, -1, -1, 0, 7, 1, 1, 0, 
+"C - - 10 - rawdatafile C - - 10 - block "
+"C - - 10 - treename U 'TCanvas' - 0 '0' rawCanvas "
+"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '0' xaxismin "
+"i - 'Int_t' 0 '4096' xaxismax", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("ShowRawSpectra",1437,G__AculDataCint_620_0_12, 121, -1, -1, 0, 6, 1, 1, 0, 
+"C - - 10 - filename i - 'Int_t' 10 - block "
+"U 'TCanvas' - 0 '0' rawCanvas i - 'Int_t' 0 '0' xaxismin "
+"i - 'Int_t' 0 '4096' xaxismax i - 'Int_t' 10 '16' subaddress", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("ShowSpectra",1139,G__AculDataCint_620_0_13, 121, -1, -1, 0, 6, 1, 1, 0, 
+"C - - 10 - filename U 'TCanvas' - 0 '0' rawCanvas "
+"C - 'Option_t' 10 '\"\"' option i - 'Int_t' 0 '0' xaxismin "
+"i - 'Int_t' 0 '4096' xaxismax i - 'Int_t' 10 '16' subaddress", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("ShowAnalyzedSpectra",1963,G__AculDataCint_620_0_14, 121, -1, -1, 0, 5, 1, 1, 0, 
+"C - - 10 - filename U 'TCanvas' - 0 '0' fittedRawCanvas "
+"i - 'Int_t' 0 '0' xaxismin i - 'Int_t' 0 '4096' xaxismax "
+"i - 'Int_t' 0 '16' subaddress", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("ShowEnergySpectra",1757,G__AculDataCint_620_0_15, 121, -1, -1, 0, 6, 1, 1, 0, 
+"C - - 10 - filename U 'TCanvas' - 0 '0' energyCanvas "
+"i - 'Int_t' 10 '16' subaddress C - 'Option_t' 10 '\"\"' option "
+"d - 'Double_t' 0 '0.' xaxismin d - 'Double_t' 0 '10.' xaxismax", "option: \"sum\", \"c\", \"+\",", (void*) NULL, 0);
+   G__memfunc_setup("DivideCanvas",1201,G__AculDataCint_620_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
+"U 'TCanvas' - 0 - c1 i - 'Int_t' 0 - inputs", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("AddCalFileToList",1528,G__AculDataCint_620_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 '\"CalFileList.log\"' calfilelist", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("ClearHistograms",1544,G__AculDataCint_620_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("DeleteStacks",1212,G__AculDataCint_620_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("MakeCalibrationFile",1894,G__AculDataCint_620_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
+"C - 'Char_t' 0 - calibrationfile C - 'Char_t' 0 - calfilelist", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("Reset",515,G__AculDataCint_620_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("Class",502,G__AculDataCint_620_0_22, 85, G__get_linked_tagnum(&G__AculDataCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&AculCalibration::Class) ), 0);
+   G__memfunc_setup("Class_Name",982,G__AculDataCint_620_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&AculCalibration::Class_Name) ), 0);
+   G__memfunc_setup("Class_Version",1339,G__AculDataCint_620_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&AculCalibration::Class_Version) ), 0);
+   G__memfunc_setup("Dictionary",1046,G__AculDataCint_620_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&AculCalibration::Dictionary) ), 0);
+   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__AculDataCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
+   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
+   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AculDataCint_620_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("DeclFileName",1145,G__AculDataCint_620_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&AculCalibration::DeclFileName) ), 0);
+   G__memfunc_setup("ImplFileLine",1178,G__AculDataCint_620_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&AculCalibration::ImplFileLine) ), 0);
+   G__memfunc_setup("ImplFileName",1171,G__AculDataCint_620_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&AculCalibration::ImplFileName) ), 0);
+   G__memfunc_setup("DeclFileLine",1152,G__AculDataCint_620_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&AculCalibration::DeclFileLine) ), 0);
+   // automatic destructor
+   G__memfunc_setup("~AculCalibration", 1643, G__AculDataCint_620_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
+   G__tag_memfunc_reset();
+}
+
+static void G__setup_memfuncConfigDictionary(void) {
+   /* ConfigDictionary */
+   G__tag_memfunc_setup(G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary));
+   G__memfunc_setup("ConfigDictionary",1644,G__AculDataCint_671_0_1, 105, G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("ConfigDictionary",1644,G__AculDataCint_671_0_2, 105, G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary), -1, 0, 1, 1, 1, 0, "u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("Class",502,G__AculDataCint_671_0_3, 85, G__get_linked_tagnum(&G__AculDataCintLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&ConfigDictionary::Class) ), 0);
+   G__memfunc_setup("Class_Name",982,G__AculDataCint_671_0_4, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ConfigDictionary::Class_Name) ), 0);
+   G__memfunc_setup("Class_Version",1339,G__AculDataCint_671_0_5, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&ConfigDictionary::Class_Version) ), 0);
+   G__memfunc_setup("Dictionary",1046,G__AculDataCint_671_0_6, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&ConfigDictionary::Dictionary) ), 0);
+   G__memfunc_setup("IsA",253,G__AculDataCint_671_0_7, 85, G__get_linked_tagnum(&G__AculDataCintLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
+   G__memfunc_setup("ShowMembers",1132,G__AculDataCint_671_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
+   G__memfunc_setup("Streamer",835,G__AculDataCint_671_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
+   G__memfunc_setup("StreamerNVirtual",1656,G__AculDataCint_671_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("DeclFileName",1145,G__AculDataCint_671_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ConfigDictionary::DeclFileName) ), 0);
+   G__memfunc_setup("ImplFileLine",1178,G__AculDataCint_671_0_12, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ConfigDictionary::ImplFileLine) ), 0);
+   G__memfunc_setup("ImplFileName",1171,G__AculDataCint_671_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&ConfigDictionary::ImplFileName) ), 0);
+   G__memfunc_setup("DeclFileLine",1152,G__AculDataCint_671_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&ConfigDictionary::DeclFileLine) ), 0);
+   G__memfunc_setup("ToString",826,G__AculDataCint_671_0_15, 117, G__get_linked_tagnum(&G__AculDataCintLN_string), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("FromString",1035,G__AculDataCint_671_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("GetString",919,G__AculDataCint_671_0_17, 117, G__get_linked_tagnum(&G__AculDataCintLN_string), -1, 0, 1, 1, 1, 32, "u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("GetInt",587,G__AculDataCint_671_0_18, 105, -1, -1, 0, 1, 1, 1, 32, "u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("GetDouble",891,G__AculDataCint_671_0_19, 100, -1, -1, 0, 1, 1, 1, 32, "u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("GetBool",684,G__AculDataCint_671_0_20, 103, -1, -1, 0, 1, 1, 1, 32, "u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SetString",931,G__AculDataCint_671_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
+"u 'string' - 0 - - u 'string' - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SetDouble",903,G__AculDataCint_671_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
+"u 'string' - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SetInt",599,G__AculDataCint_671_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
+"u 'string' - 0 - - i - - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("SetBool",696,G__AculDataCint_671_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
+"u 'string' - 0 - - g - - 0 - -", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("Begin",485,G__AculDataCint_671_0_25, 117, G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), G__defined_typename("ConfigDictionary::CDIter"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   G__memfunc_setup("End",279,G__AculDataCint_671_0_26, 117, G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator), G__defined_typename("ConfigDictionary::CDIter"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
+   // automatic copy constructor
+   G__memfunc_setup("ConfigDictionary", 1644, G__AculDataCint_671_0_27, (int) ('i'), G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary), -1, 0, 1, 1, 1, 0, "u 'ConfigDictionary' - 11 - -", (char*) NULL, (void*) NULL, 0);
+   // automatic destructor
+   G__memfunc_setup("~ConfigDictionary", 1770, G__AculDataCint_671_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
+   // automatic assignment operator
+   G__memfunc_setup("operator=", 937, G__AculDataCint_671_0_29, (int) ('u'), G__get_linked_tagnum(&G__AculDataCintLN_ConfigDictionary), -1, 1, 1, 1, 1, 0, "u 'ConfigDictionary' - 11 - -", (char*) NULL, (void*) NULL, 0);
+   G__tag_memfunc_reset();
+}
+
+
+/*********************************************************
+* Member function information setup
+*********************************************************/
+extern "C" void G__cpp_setup_memfuncAculDataCint() {
+}
+
+/*********************************************************
+* Global variable information setup for each class
+*********************************************************/
+static void G__cpp_setup_global0() {
+
+   /* Setting up global variables */
+   G__resetplocal();
+
+}
+
+static void G__cpp_setup_global1() {
+}
+
+static void G__cpp_setup_global2() {
+}
+
+static void G__cpp_setup_global3() {
+}
+
+static void G__cpp_setup_global4() {
+
+   G__resetglobalenv();
+}
+extern "C" void G__cpp_setup_globalAculDataCint() {
+  G__cpp_setup_global0();
+  G__cpp_setup_global1();
+  G__cpp_setup_global2();
+  G__cpp_setup_global3();
+  G__cpp_setup_global4();
+}
+
+/*********************************************************
+* Global function information setup for each class
+*********************************************************/
+static void G__cpp_setup_func0() {
+   G__lastifuncposition();
+
+}
+
+static void G__cpp_setup_func1() {
+}
+
+static void G__cpp_setup_func2() {
+}
+
+static void G__cpp_setup_func3() {
+}
+
+static void G__cpp_setup_func4() {
+}
+
+static void G__cpp_setup_func5() {
+}
+
+static void G__cpp_setup_func6() {
+}
+
+static void G__cpp_setup_func7() {
+}
+
+static void G__cpp_setup_func8() {
+}
+
+static void G__cpp_setup_func9() {
+}
+
+static void G__cpp_setup_func10() {
+}
+
+static void G__cpp_setup_func11() {
+}
+
+static void G__cpp_setup_func12() {
+}
+
+static void G__cpp_setup_func13() {
+}
+
+static void G__cpp_setup_func14() {
+}
+
+static void G__cpp_setup_func15() {
+}
+
+static void G__cpp_setup_func16() {
+}
+
+static void G__cpp_setup_func17() {
+}
+
+static void G__cpp_setup_func18() {
+
+   G__resetifuncposition();
+}
+
+extern "C" void G__cpp_setup_funcAculDataCint() {
+  G__cpp_setup_func0();
+  G__cpp_setup_func1();
+  G__cpp_setup_func2();
+  G__cpp_setup_func3();
+  G__cpp_setup_func4();
+  G__cpp_setup_func5();
+  G__cpp_setup_func6();
+  G__cpp_setup_func7();
+  G__cpp_setup_func8();
+  G__cpp_setup_func9();
+  G__cpp_setup_func10();
+  G__cpp_setup_func11();
+  G__cpp_setup_func12();
+  G__cpp_setup_func13();
+  G__cpp_setup_func14();
+  G__cpp_setup_func15();
+  G__cpp_setup_func16();
+  G__cpp_setup_func17();
+  G__cpp_setup_func18();
+}
+
+/*********************************************************
+* Class,struct,union,enum tag information setup
+*********************************************************/
+/* Setup class/struct taginfo */
+G__linked_taginfo G__AculDataCintLN_TClass = { "TClass" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TBuffer = { "TBuffer" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TObject = { "TObject" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_string = { "string" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TObjArray = { "TObjArray" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
+G__linked_taginfo G__AculDataCintLN_TFile = { "TFile" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TH1 = { "TH1" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TCanvas = { "TCanvas" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_THStack = { "THStack" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_AculCalibration = { "AculCalibration" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_ConfigDictionary = { "ConfigDictionary" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR = { "map<string,string,less<string>,allocator<pair<const string,string> > >" , 99 , -1 };
+G__linked_taginfo G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator = { "map<string,string,less<string>,allocator<pair<const string,string> > >::iterator" , 99 , -1 };
+
+/* Reset class/struct taginfo */
+extern "C" void G__cpp_reset_tagtableAculDataCint() {
+  G__AculDataCintLN_TClass.tagnum = -1 ;
+  G__AculDataCintLN_TBuffer.tagnum = -1 ;
+  G__AculDataCintLN_TMemberInspector.tagnum = -1 ;
+  G__AculDataCintLN_TObject.tagnum = -1 ;
+  G__AculDataCintLN_string.tagnum = -1 ;
+  G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
+  G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
+  G__AculDataCintLN_TObjArray.tagnum = -1 ;
+  G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
+  G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
+  G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
+  G__AculDataCintLN_TFile.tagnum = -1 ;
+  G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
+  G__AculDataCintLN_TH1.tagnum = -1 ;
+  G__AculDataCintLN_TVectorTlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TVectorTlEdoublegR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
+  G__AculDataCintLN_TCanvas.tagnum = -1 ;
+  G__AculDataCintLN_THStack.tagnum = -1 ;
+  G__AculDataCintLN_AculCalibration.tagnum = -1 ;
+  G__AculDataCintLN_TElementActionTlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TElementPosActionTlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTRowlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTSublEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
+  G__AculDataCintLN_ConfigDictionary.tagnum = -1 ;
+  G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR.tagnum = -1 ;
+  G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator.tagnum = -1 ;
+}
+
+
+extern "C" void G__cpp_setup_tagtableAculDataCint() {
+
+   /* Setting up class,struct,union tag entry */
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TClass);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TBuffer);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMemberInspector);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TObject);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_string);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TObjArray);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TFile);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TH1);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TVectorTlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TVectorTlEdoublegR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTBaselEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTBaselEdoublegR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TCanvas);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_THStack);
+   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__AculDataCintLN_AculCalibration),sizeof(AculCalibration),-1,62720,(char*)NULL,G__setup_memvarAculCalibration,G__setup_memfuncAculCalibration);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TElementActionTlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TElementPosActionTlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTRow_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTRowlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTDiag_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTColumn_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTFlat_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTSub_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTColumnlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTDiaglEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTFlatlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTSublEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTSparseRowlEfloatgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR);
+   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__AculDataCintLN_ConfigDictionary),sizeof(ConfigDictionary),-1,34048,(char*)NULL,G__setup_memvarConfigDictionary,G__setup_memfuncConfigDictionary);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR);
+   G__get_linked_tagnum_fwd(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator);
+}
+extern "C" void G__cpp_setupAculDataCint(void) {
+  G__check_setup_version(30051515,"G__cpp_setupAculDataCint()");
+  G__set_cpp_environmentAculDataCint();
+  G__cpp_setup_tagtableAculDataCint();
+
+  G__cpp_setup_inheritanceAculDataCint();
+
+  G__cpp_setup_typetableAculDataCint();
+
+  G__cpp_setup_memvarAculDataCint();
+
+  G__cpp_setup_memfuncAculDataCint();
+  G__cpp_setup_globalAculDataCint();
+  G__cpp_setup_funcAculDataCint();
+
+   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncAculDataCint();
+  return;
+}
+class G__cpp_setup_initAculDataCint {
+  public:
+    G__cpp_setup_initAculDataCint() { G__add_setup_func("AculDataCint",(G__incsetup)(&G__cpp_setupAculDataCint)); G__call_setup_funcs(); }
+   ~G__cpp_setup_initAculDataCint() { G__remove_setup_func("AculDataCint"); }
+};
+G__cpp_setup_initAculDataCint G__cpp_setup_initializerAculDataCint;
+

AculData/AculDataCint.h

+/********************************************************************
+* /home/dariak/Utilities/AculData/AculDataCint.h
+* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
+*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
+*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
+********************************************************************/
+#ifdef __CINT__
+#error /home/dariak/Utilities/AculData/AculDataCint.h/C is only for compilation. Abort cint.
+#endif
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+#include <string.h>
+#define G__ANSIHEADER
+#define G__DICTIONARY
+#define G__PRIVATE_GVALUE
+#include "G__ci.h"
+#include "FastAllocString.h"
+extern "C" {
+extern void G__cpp_setup_tagtableAculDataCint();
+extern void G__cpp_setup_inheritanceAculDataCint();
+extern void G__cpp_setup_typetableAculDataCint();
+extern void G__cpp_setup_memvarAculDataCint();
+extern void G__cpp_setup_globalAculDataCint();
+extern void G__cpp_setup_memfuncAculDataCint();
+extern void G__cpp_setup_funcAculDataCint();
+extern void G__set_cpp_environmentAculDataCint();
+}
+
+
+#include "TObject.h"
+#include "TMemberInspector.h"
+#include "/home/dariak/Utilities/AculData/AculCalibration.h"
+#include "/home/dariak/Utilities/AculData/ConfigDictionary.h"
+#include <algorithm>
+namespace std { }
+using namespace std;
+
+#ifndef G__MEMFUNCBODY
+#endif
+
+extern G__linked_taginfo G__AculDataCintLN_TClass;
+extern G__linked_taginfo G__AculDataCintLN_TBuffer;
+extern G__linked_taginfo G__AculDataCintLN_TMemberInspector;
+extern G__linked_taginfo G__AculDataCintLN_TObject;
+extern G__linked_taginfo G__AculDataCintLN_string;
+extern G__linked_taginfo G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR;
+extern G__linked_taginfo G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR;
+extern G__linked_taginfo G__AculDataCintLN_TObjArray;
+extern G__linked_taginfo G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR;
+extern G__linked_taginfo G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR;
+extern G__linked_taginfo G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR;
+extern G__linked_taginfo G__AculDataCintLN_TFile;
+extern G__linked_taginfo G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR;
+extern G__linked_taginfo G__AculDataCintLN_TH1;
+extern G__linked_taginfo G__AculDataCintLN_TVectorTlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TVectorTlEdoublegR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTBaselEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTBaselEdoublegR;
+extern G__linked_taginfo G__AculDataCintLN_TCanvas;
+extern G__linked_taginfo G__AculDataCintLN_THStack;
+extern G__linked_taginfo G__AculDataCintLN_AculCalibration;
+extern G__linked_taginfo G__AculDataCintLN_TElementActionTlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TElementPosActionTlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTRow_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTRowlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTDiag_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTColumn_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTFlat_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTSub_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTColumnlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTDiaglEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTFlatlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTSublEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTSparseRowlEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR;
+extern G__linked_taginfo G__AculDataCintLN_ConfigDictionary;
+extern G__linked_taginfo G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR;
+extern G__linked_taginfo G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator;
+
+/* STUB derived class for protected member access */

AculData/ConfigDictionary.cpp

+#include "ConfigDictionary.h"
+
+ClassImp(ConfigDictionary);
+
+//////////////////////////////////////////////////////////////////////////////
+//	BEGIN_HTML
+//	<p><font size="4"><b>Config(uration)Dictionary class</b></font></p>
+//  <br>
+// 	<i>Author: Bartlomiej Hnatio 2012-08-06</i>
+//	<br><br>
+//	This is very useful class to convert strings containing pairs "key"="value"
+//	into fast dictionaries. This strings are often read from external files.
+//	From dictionary created in such way one can easily
+//	extract values in few supported formats (integer, double, boolean, string)
+//	It can also be used in opposite direction: when dictionary is created with
+// 	given values and keys, one can create config string, which is most
+//	convenient to write in external files.
+//	<br><br><br>
+//	<u>Most simple example of usage:</u>
+//	<br><br>Suppose you have two variables fD and fI:
+//	<pre>-------------------
+//    Double_t fD;
+//    Int_t fI;
+//
+//fD = 3.14;
+//fI = 2012;
+//-----------------------</pre>
+//	To save its parameters into file you can create ConfigDictionary class
+//	instance and use <b>SetDouble</b> and <b>SetInt</b> functions to
+//	insert parameters values with arbitrarly defined keys (let them be
+//	really long and descriptive in this example):
+//	<pre>---------------------
+//ConfigDictionary CD;
+//CD.SetDouble("Most important variable D",fD);
+//CD.SetInt("Equally important integer I",fI);
+//---------------------</pre>
+//	Now configuration string saved in <b>ConfigDictionary</b> CD
+//	can be obtained with <b>ToString</b> method and should look like:
+//<pre>
+//"Most important variable D"="3.14" "Equally important integer I"="2012"
+//</pre>
+//	<br> It can be easily saved to a file using simplest <i>fstream</i>
+//	methods. And the advantage is that as a key one can use any string,
+//	so configuration file created in such way is very self-explanatory.
+//	<br>
+//	<br>
+//	Now lets suppose the opposite action - loading config from file.
+//	Imagine, that you have 1000 objects of A class, which config was saved
+//	to file - one object per line:
+//	<pre>-----------------
+//"Most important variable D"="3.14" "Equally important integer I"="2012"
+//"Equally important integer I"="1011" "Most important variable D"="8.15"
+//"Most important variable D"="13.16" "Equally important integer I"="10"
+//(...)
+//----------------</pre>
+//	Please notice that order in which pairs of keys and values are placed
+//  in file doesn't make any difference to the ConfigDictionary class.
+//	To recreate objects, you just read each	line containing single
+//	config string and then create with it ConfigDictionary object
+//  using special constructor with string as argument,
+//	or using <b>FromString</b> method. After this, you can
+// 	extract parameters (using <b>GetDouble</b> and <b>GetInt</b> methods)
+//	with using same keys as were used for saving, and ConfigDictionary
+//	will return their values:
+//	<pre>----------------------
+//string line;//This line you read from file
+//ConfigDictionary CD(line);
+//fD = CD.GetDouble("Most important variable D");
+//fI = CD.GetInt("Equally important integer I");
+//--------------------</pre>
+//<br>
+//	And last but not least: what happens, if key requested by user doesn't
+//	exist in dictionary? (This can be caused by many reasons, mostly errors on
+// 	user side, but not always).
+//	When you try to extract non-existent key using <b>Get</b> functions,
+//	an exception is risen. In normal program it should end execution and print
+//	some information about where program stopped working.
+//	But lets say that you don't want that, i.e. program may use default
+//  configs instead of those from files, or not all keys were that important.
+//	You can surround all uses of <b>Get</b> methods with try/catch clause.
+//	So when exception is risen, you will catch it, and decide, if you want
+//	the program to stop running, or anything else. Simple example is
+//	shown below:
+//<pre>-------------------
+//ConfigDictionary CD(some_string);
+//try{//try to read important variables:
+//  double d = CD.GetDouble("crucial var");
+//  bool b = CD.GetBool("most important b");
+//  int i = CD.GetInt("unique ID");
+//  //...and so on
+//}catch(std::string & e){//catch any kind of exception
+//  Error("Some crucial variable wasn't read, ending program!");
+//  return SOME_REALLY_BAD_ERROR_CODE;
+//}
+//try{//now less important, or optional:
+//  string name = CD.GetString("least important variable");
+//  double p = CD.GetDouble("optional parameter");
+//  //...and so on
+//}catch(std::string & f){
+//  Info("Some optional variables wasn't read!");
+//}
+//--------------------</pre>
+//	END_HTML
+//////////////////////////////////////////////////////////////////////////////
+
+//_____________________________________________________________________________
+ConfigDictionary::ConfigDictionary(){
+	//just empty map...
+}
+
+//_____________________________________________________________________________
+ConfigDictionary::ConfigDictionary(std::string params){
+	//Just creates dictionary using FromString method
+	FromString(params);
+}
+
+//_____________________________________________________________________________
+std::string ConfigDictionary::ToString(){
+	//Builds string that can be easily saved to file.
+	//Same format that can be read from files or from QtGui
+	//This should work same way for all uses
+
+	std::map<std::string,std::string>::iterator it;//Iterator to map elements
+	std::stringstream ss;//stream helpful with adding strings
+	//iterate whole dictionary:
+	for (it=configMap.begin();it!=configMap.end();++it){
+		//insert pairs "key"="value":
+		ss<<"\""<<it->first<<"\""<<"="<<"\""<<it->second<<"\""<<" ";
+	}
+	return ss.str();
+}
+
+//_____________________________________________________________________________
+void ConfigDictionary::FromString(std::string params){
+	//params - TString containing list of key=value pairs
+	//
+	//Changes string formatted:
+	//"key1"="value1" "key2"="value with spaces 2" ...
+	//into map with keys and values
+	//Useful in lots of I/O functions,
+	//when we want to have a nice, readable format of data
+
+	std::stringstream loading(params);
+	std::string k,v;
+
+	while(!loading.fail()){
+		getline(loading,k,'\"');//removes everything to first "
+		getline(loading,k,'\"');//All chars between first two "" are the key
+		getline(loading,v,'\"');//removes all until third "
+		getline(loading,v,'\"');//All between another pair of "" is the value
+		if (!loading.fail())
+		    configMap[k]=v;
+	}
+}
+
+//_____________________________________________________________________________
+std::string ConfigDictionary::GetString(std::string key)throw(std::string){
+	//Extracts string from given key
+	//(if it exist, otherwise raises exception)
+
+	if (configMap.find(key) == configMap.end()){
+		Error("ConfigDictionary::GetString",
+				"Couldn't find the key: %s!",key.c_str());
+		throw(key);
+	}
+	return configMap[key];
+}
+
+//_____________________________________________________________________________
+int	ConfigDictionary::GetInt(std::string key)throw(std::string){
+	//Extracts integer from given key
+	//(if it exist, otherwise raises exception)
+	if (configMap.find(key) == configMap.end()){
+		Error("ConfigDictionary::GetInt",
+				"Couldn't find the key: %s!",key.c_str());
+		throw(key);
+	}
+	int returned=0;
+	//Convert string to int:
+	std::stringstream ss(configMap[key]);
+	ss>>returned;
+	return returned;
+}
+
+//_____________________________________________________________________________
+double ConfigDictionary::GetDouble(std::string key)throw(std::string){
+	//Extracts integer from given key
+	//(if it exist, otherwise raises exception)
+	if (configMap.find(key) == configMap.end()){
+		Error("ConfigDictionary::GetDouble",
+				"Couldn't find the key: %s!",key.c_str());
+		throw(key);
+	}
+	double returned=0.0;
+	//Convert string to double:
+	std::stringstream ss(configMap[key]);
+	ss>>returned;
+	return returned;
+}
+
+//_____________________________________________________________________________
+bool ConfigDictionary::GetBool(std::string key)throw(std::string){
+	//Extracts boolean from given key
+	//(if it exist, otherwise raises exception)
+	if (configMap.find(key) == configMap.end()){
+		Error("ConfigDictionary::GetBool",
+				"Couldn't find the key: %s!",key.c_str());
+		throw(key);
+	}
+	//Convert string to bool:
+	if (configMap[key].compare("true") == 0)
+		return true;
+	else return false;
+}
+
+//_____________________________________________________________________________
+void ConfigDictionary::SetString(std::string key,std::string value){
+	//Sets value to key, no comments needed here...
+	configMap[key] = value;
+}
+
+//_____________________________________________________________________________
+void ConfigDictionary::SetDouble(std::string key,double value){
+	//Sets value to key, converts double to string first
+	std::stringstream ss;
+	ss<<value;
+	configMap[key] = ss.str();
+}
+
+//_____________________________________________________________________________
+void ConfigDictionary::SetInt(std::string key,int value){
+	//Sets value to key, converts int to string first
+	std::stringstream ss;
+	ss<<value;
+	configMap[key] = ss.str();
+}
+
+//_____________________________________________________________________________
+void ConfigDictionary::SetBool(std::string key,bool value){
+	//Sets value to key, converts bool to string first
+	if (value == true)	configMap[key] = "true";
+	else				configMap[key] = "false";
+}

AculData/ConfigDictionary.h

+#ifndef CONFIGDICTIONARY_H
+#define CONFIGDICTIONARY_H
+
+
+#include "TObject.h"
+#include "ReturnCodes.h"
+#include "TStopwatch.h"
+#include "TROOT.h"
+#include <string>
+#include <map>
+#include <sstream>
+#include "TLorentzVector.h"
+#include <iostream>
+#include "TMath.h"
+#include "TString.h"
+#include "TTree.h"
+
+
+class ConfigDictionary{
+public:
+	typedef std::map<std::string,std::string>::iterator CDIter;
+	ConfigDictionary();
+	ConfigDictionary(std::string);
+	virtual ~ConfigDictionary(){};//empty virtual destructor
+
+	ClassDef(ConfigDictionary,1);
+	std::string ToString();
+	void FromString(std::string);
+
+	//These throw errors if couldn't find key:
+	std::string GetString(std::string)throw(std::string);
+	int	GetInt(std::string)throw(std::string);
+	double GetDouble(std::string)throw(std::string);
+	bool GetBool(std::string)throw(std::string);
+
+	//These will always set 'something' into map:
+	void SetString(std::string,std::string);
+	void SetDouble(std::string,double);
+	void SetInt(std::string,int);
+	void SetBool(std::string,bool);
+	
+	CDIter Begin(){return configMap.begin();};
+	CDIter End(){return configMap.end();};
+
+private:
+	std::map<std::string,std::string> configMap;
+};
+
+#endif

AculData/ReturnCodes.h

+#ifndef RETURN_CODES_H
+#define RETURN_CODES_H
+
+//Some useful return codes
+
+  const static int SUCCESS = 0;
+  const static int IOEXCEPTION = -1;
+  const static int NOTFOUND = -2;
+  const static int NULLPOINTER = -3;
+  const static int UNKNOWN = -4;
+  const static int FAILURE = -5;
+  const static int CDEXCEPTION = -6;
+  const static int EMPTYCONTAINER = -7;
+  const static int NOTDEFINED = -8;
+  const static int EXCEPTION = -11;
+
+#endif

AculData/linkdef.h

+#ifdef __CINT__
+#pragma link off all globals;
+#pragma link off all classes;
+#pragma link off all functions;
+
+//#pragma link C++ class AculRaw;
+//#pragma link C++ class AculConvert;
+#pragma link C++ class AculCalibration;
+#pragma link C++ class ConfigDictionary;
+
+
+#endif
+

README

+1) set path in makefile according to your operating system
+
+2) type in terminal:
+
+	make all
+	make htmldoc
+	make install
+
+3) add the install folder to LD_LIBRARY_PATH

calibration1.cxx

+{
+	gSystem->Load("/home/dariak/Utilities/libAculData.so");
+
+	AculCalibration cal;
+	cal.SetInputParameters();
+	cal.CalculateCalibParameters("clb01_0001.root", "SQ22", 22, "AnalysisxTree", 50, 700);
+
+	TCanvas *c1 = new TCanvas();
+
+//	cal->ShowRawSpectra("clb01_0001.root", 22, c1);
+//	cal.ShowSpectra("SQ22[].root", c1, "", 300, 800, 10);
+
+
+//	TFile filerootE("SQ22[]E.root");
+//	TFile filecal("SQ22[].cal");
+
+//	TDirectory dir("dir","dash");
+//	dir.Add("SQ22[].root");
+
+
+}

calibration2.cxx

+{
+	gSystem->Load("/home/dariak/Utilities/libAculData.so");
+
+	AculCalibration cal;
+	cal->SetInputParameters();
+
+
+	TCanvas *c1 = new TCanvas();
+
+	TFile fr("SQ22[]E.root");
+//	TH1F *h1 = (TH1F*)fr.Get("HistSQ22[10]E");
+//	h1->Draw();
+
+	cout << fr.GetListOfKeys()->GetEntries() << " histograms" << endl;
+
+	TList *histList = fr.GetListOfKeys();
+	const Int_t noHist = histList->GetEntries();
+
+	const Double_t minE = 3;
+	const Double_t maxE = 8;
+	Int_t minBin, maxBin;
+
+	TH1 *hWork = 0;
+	c1->Clear();
+	c1->Divide(6, 6);
+	for (Int_t i = 0; i < 32; i++) {
+		fr.GetObject(histList->At(i)->GetName(), hWork);		
+		c1->cd(i+1);
+		cal->PeaksFitting(hWork);
+		hWork->Draw();
+	}
+
+}

calibrationBranch.cxx

+{
+	gSystem->Load("~/workspace/Utilities/libAculData.so");
+
+	TFile fr("clb01_0001.root");
+
+	TTree *tr = (TTree*)fr.Get("AnalysisxTree");
+
+	tr->Draw("SQ22[0]", "SQ22[0]>100");
+
+
+}

html.cxx

+{
+//	gROOT->GetPluginManager()->AddHandler("TVirtualStreamerInfo","*", "TStreamerInfo", "RIO", "TStreamerInfo()");
+	
+	gSystem->Load("./libAculData.so");
+//	gSystem->Load("~/work/makefilesBe/libTELoss.so");
+//	gSystem->Load("~/work/makefilesBe/libDetectors.so");
+//	gSystem->Load("~/work/makefilesBe/libDetectors.so");
+//	gSystem->Load("~/work/makefilesBe/libBe.so");
+
+	THtml h;
+
+	h.SetInputDir(".");
+//	h.MakeIndex("");
+//	h.MakeClass("TELoss");
+//	h.MakeClass("TELoss");
+//	h.MakeClass("TELoss");
+
+	h.MakeAll();
+
+	/*h.SetInputDir("/media/commondata/work/Eclipse/AculData/Debug:/media/commondata/work/Eclipse/AculData:"
+			"../Detectors/Debug:../Detectors:"
+			"../TELoss/Debug:../TELoss:"
+			"../Be/Debug:../Be:"
+			);*/
+//	h.MakeIndex("");
+
+	/*h.SetInputDir("/media/commondata/work/makefiles/AculData/Debug:/media/commondata/work/Eclipse/AculData:"
+			"../Detectors/Debug:../Detectors:"
+			"../TELoss/Debug:../TELoss:"
+			"../Be/Debug:../Be:"
+			);*/
+//			"$ROOTSYS/include/root");
+
+//	h.MakeAll();
+
+//	h.MakeClass("AculRaw");
+//	h.MakeClass("AculConvert");
+//	h.MakeClass("AculCalibration");
+//
+//	h.MakeClass("AnnularDetector");
+//
+//	h.MakeClass("TELoss");
+//
+//	h.MakeClass("TObject");
+//	h.MakeClass("TClass");
+
+}

load.cxx

+{
+	gSystem->Load("~/workspace/Utilities/libAculData.so");
+
+}

makefile

+################################################################################
+# Makefile building all dynamic libraries:
+# libCalib.so
+#
+#	OBJS - files type *.o (subdir.mk)
+#	LIBS - list of the loaded libraries (objects.mk)
+#	RM - command "rm -rf"
+#	CPP_DEPS - files type *.d (subdir.mk)
+#	.PHONY - 
+#	.SECONDARY - 
+#	
+# Vratislav Chudoba
+################################################################################
+
+RM := rm -rf
+
+CC := g++
+
+F90 := gfortran
+
+#global paths
+ROOTINCS = $(shell root-config --incdir)
+ROOTLIBS = $(shell root-config --libdir)
+ROOTCFLAGS = $(shell root-config --cflags)
+PWD = $(shell pwd)
+#INSTALLFOLDER = $(HOME)/AculLib
+
+ACULDATA = $(PWD)/AculData
+
+-include $(ACULDATA)/AculData.mk
+
+all: libAculData.so \
+
+
+#ROOT html documentation, it will be done as a program which will be alsa compiled by this makefile, program will be as a last condition after all of the libraries
+htmldoc: libAculData.so
+	-$(RM) htmldoc
+	root -l -q html.cxx	
+
+clean:
+	-$(RM) $(ACULDATAOBJS) $(ACULDATACPP_DEPS) 
+	-$(RM) $(ACULDATA)/AculDataCint.* libAculData.so
+	-@echo ' '
+	-$(RM) htmldoc
+	-@echo ' '
+
+# Those *Cint* files below need special treating:
+$(ACULDATA)/AculDataCint.cpp:
+	-@echo 'Pre-building AculDataCint.cpp and AculDataCint.h files'
+	-rootcint -f $(ACULDATA)/AculDataCint.cpp -c -p $(ACULDATA_HEADERS)
+	-@echo ' '
+
+#*.so files
+libAculData.so: $(ACULDATAOBJS)
+	@echo 'Building target: $@'
+	@echo 'Invoking: GCC C++ Linker'
+	$(CC) -L $(ROOTLIBS) -shared -o"libAculData.so" $(ACULDATAOBJS) $(ACULDATALIBS)
+	@echo 'Finished building target: $@'
+	@echo ' '
+
+	
+.PHONY: all clean
+#.SECONDARY: AculData_pre-build TELoss_pre-build Detectors_pre-build libAculData.so libTELoss.so libDetectors.so
+
+# Each subdirectory must supply rules for building sources it contributes
+%.o: %.cpp
+	@echo 'Building file: $@'
+	@echo 'Invoking: $(CC) Compiler'
+	$(CC) -I$(ROOTINCS) -O0 -g3 -Wall -c -fmessage-length=0 -fPIC $(ROOTCFLAGS) -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"
+#	$(CC) -I$(ROOTINCS) -O2 -Wall -mmmx -msse -msse2 -msse3 -mfpmath=sse,387 -march=nocona -mtune=nocona -c -fmessage-length=0 -fPIC -MMD -MP -MF"$(@:%.o=%.d)" -MT"$(@:%.o=%.d)" -o"$@" "$<"
+	@echo 'Finished building: $@'
+	@echo ' '
+
+# fortran object files
+$(TELOSS)/ELOSS.o:
+	@echo 'Building file: $@'
+	@echo 'Invoking: gfortran'
+	$(F90) -c -fPIC -o"$(TELOSS)/ELOSS.o" $(TELOSS)/ELOSS.f90
+	@echo 'Finished building target: $@'
+	@echo ' '

parforcal.par

+//226Ra
+
+4	nopeaks	//number of peaks
+4.784	E1	//in MeV
+5.490   E2	//in MeV
+6.002	E3	//in MeV
+7.687	E4	//in MeV
+100	lowerchannel	//in channels
+4096	upperchannel	//in channels
+0.35	lowerpeakhight	//in relative units
+0.5	upperpeakhight	//in relative units
+0.1	peakpositiontolerance	//in relative units
+2	fitfunctionlinewidth		//integer 1 - 10
+5	minfitsigma	//minimal sigma of the peaks to be fitted
+0.4	fithightthreshold	//