Commit 9f9bdbb4 authored by Kostyleva D.A's avatar Kostyleva D.A

initial commit

parent b90755d7
*~
*.root
*.cal
//////////////////////////////////////////////////////////
// //
// 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;
}
#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 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
//
// 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;
/********************************************************************
* /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 */
#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";
}
#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
#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
#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
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
{
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");
}
{
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();
}
}
{
gSystem->Load("~/workspace/Utilities/libAculData.so");
TFile fr("clb01_0001.root");
TTree *tr = (TTree*)fr.Get("AnalysisxTree");
tr->Draw("SQ22[0]", "SQ22[0]>100");
}
{
// 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");
}
{
gSystem->Load("~/workspace/Utilities/libAculData.so");
}
################################################################################
# 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 ' '
//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 //
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment