From 9f9bdbb4d1b854eafbe3bba9220f58bc7a609de7 Mon Sep 17 00:00:00 2001 From: "Kostyleva D.A" Date: Wed, 28 Sep 2016 18:41:57 +0300 Subject: [PATCH] initial commit --- .gitignore | 3 + AculData/AculCalibration.cpp | 1204 +++++++++++++++++++++ AculData/AculCalibration.h | 210 ++++ AculData/AculData.mk | 26 + AculData/AculDataCint.cpp | 1905 +++++++++++++++++++++++++++++++++ AculData/AculDataCint.h | 85 ++ AculData/ConfigDictionary.cpp | 243 +++++ AculData/ConfigDictionary.h | 49 + AculData/ReturnCodes.h | 17 + AculData/linkdef.h | 13 + README | 9 + calibration1.cxx | 21 + calibration2.cxx | 33 + calibrationBranch.cxx | 11 + html.cxx | 47 + load.cxx | 4 + makefile | 80 ++ parforcal.par | 15 + 18 files changed, 3975 insertions(+) create mode 100644 .gitignore create mode 100755 AculData/AculCalibration.cpp create mode 100755 AculData/AculCalibration.h create mode 100755 AculData/AculData.mk create mode 100644 AculData/AculDataCint.cpp create mode 100644 AculData/AculDataCint.h create mode 100644 AculData/ConfigDictionary.cpp create mode 100644 AculData/ConfigDictionary.h create mode 100644 AculData/ReturnCodes.h create mode 100755 AculData/linkdef.h create mode 100755 README create mode 100644 calibration1.cxx create mode 100644 calibration2.cxx create mode 100644 calibrationBranch.cxx create mode 100755 html.cxx create mode 100755 load.cxx create mode 100755 makefile create mode 100755 parforcal.par diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..ab6278b --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*~ +*.root +*.cal diff --git a/AculData/AculCalibration.cpp b/AculData/AculCalibration.cpp new file mode 100755 index 0000000..98324f5 --- /dev/null +++ b/AculData/AculCalibration.cpp @@ -0,0 +1,1204 @@ +////////////////////////////////////////////////////////// +// // +// 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(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(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(atoi(parameter)); + for (Int_t i = 0; i < kRaNOPEAKS; i++) { + fipr.getline(line, lineLength); + sscanf(line, "%s", parameter); + fEnergy[i] = static_cast(atof(parameter)); + } + }//if + + if ( strcmp(identificator, "lowerchannel") == 0 ) { + sscanf(line, "%s", parameter); + fLowerChannel = static_cast(atof(parameter)); + } + + if ( strcmp(identificator, "upperchannel") == 0 ) { + sscanf(line, "%s", parameter); + fUpperChannel = static_cast(atof(parameter)); + } + + if ( strcmp(identificator, "lowerpeakhight") == 0 ) { + sscanf(line, "%s", parameter); + fLowerPeakRelativeHight = static_cast(atof(parameter)); + } + + if ( strcmp(identificator, "upperpeakhight") == 0 ) { + sscanf(line, "%s", parameter); + fUpperPeakRelativeHight = static_cast(atof(parameter)); + } + + if ( strcmp(identificator, "peakpositiontolerance") == 0 ) { + sscanf(line, "%s", parameter); + fPeakPositionTolerance = static_cast(atof(parameter)); + } + + if ( strcmp(identificator, "fitfunctionlinewidth") == 0 ) { + sscanf(line, "%s", parameter); + fFitFuncLineWidth = static_cast(atoi(parameter)); + } + + if ( strcmp(identificator, "minfitsigma") == 0 ) { + sscanf(line, "%s", parameter); + fFitMinSigma = static_cast(atof(parameter)); + } + + if ( strcmp(identificator, "fithightthreshold") == 0 ) { + sscanf(line, "%s", parameter); + fFitPeakThreshold = static_cast(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(atof(cA)); + fB[i][j] = static_cast(atof(cB)); + // fMeanSigma[i][j] = static_cast(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; +} diff --git a/AculData/AculCalibration.h b/AculData/AculCalibration.h new file mode 100755 index 0000000..00772d5 --- /dev/null +++ b/AculData/AculCalibration.h @@ -0,0 +1,210 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#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); + +}; diff --git a/AculData/AculData.mk b/AculData/AculData.mk new file mode 100755 index 0000000..27ec535 --- /dev/null +++ b/AculData/AculData.mk @@ -0,0 +1,26 @@ +################################################################################ +# 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 diff --git a/AculData/AculDataCint.cpp b/AculData/AculDataCint.cpp new file mode 100644 index 0000000..d78b920 --- /dev/null +++ b/AculData/AculDataCint.cpp @@ -0,0 +1,1905 @@ +// +// 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 &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 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 &R__stl = configMap; + int R__n=(&R__stl) ? int(R__stl.size()) : 0; + R__b << R__n; + if(R__n) { + map::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", (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*) + { + map *ptr = 0; + static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map),0); + static ::ROOT::TGenericClassInfo + instance("map", -2, "/usr/local/lib64/root/5.30/lib/cint/cint/lib/prec_stl/map", 63, + typeid(map), DefineBehavior(ptr, ptr), + 0, &maplEstringcOstringgR_Dictionary, isa_proxy, 0, + sizeof(map) ); + 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 >())); + return &instance; + } + // Static variable to force the class initialization + static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map*)0x0); R__UseDummy(_R__UNIQUE_(Init)); + + // Dictionary for non-ClassDef classes + static void maplEstringcOstringgR_Dictionary() { + ::ROOT::GenerateInitInstanceLocal((const map*)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 : new map; + } + static void *newArray_maplEstringcOstringgR(Long_t nElements, void *p) { + return p ? ::new((::ROOT::TOperatorNewHelper*)p) map[nElements] : new map[nElements]; + } + // Wrapper around operator delete + static void delete_maplEstringcOstringgR(void *p) { + delete ((map*)p); + } + static void deleteArray_maplEstringcOstringgR(void *p) { + delete [] ((map*)p); + } + static void destruct_maplEstringcOstringgR(void *p) { + typedef map current_t; + ((current_t*)p)->~current_t(); + } +} // end of namespace ROOT for class map + +/******************************************************** +* /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 +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",117,G__get_linked_tagnum(&G__AculDataCintLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_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",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",117,G__get_linked_tagnum(&G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("reverse_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",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",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("iterator",117,G__get_linked_tagnum(&G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map >",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TVectorT",117,G__get_linked_tagnum(&G__AculDataCintLN_TVectorTlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TVectorT",117,G__get_linked_tagnum(&G__AculDataCintLN_TVectorTlEdoublegR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTBase",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTBaselEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTBase",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTBaselEdoublegR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixT",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTRow_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTRow_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTColumn_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTColumn_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTDiag_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTDiag_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTFlat_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTFlat_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTSub_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSub_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTSparseRow_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTSparseDiag_const",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTRow",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTRowlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTColumn",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTColumnlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTDiag",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTDiaglEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTFlat",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTFlatlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTSub",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSublEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTSparseRow",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseRowlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TMatrixTSparseDiag",117,G__get_linked_tagnum(&G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TElementActionT",117,G__get_linked_tagnum(&G__AculDataCintLN_TElementActionTlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("TElementPosActionT",117,G__get_linked_tagnum(&G__AculDataCintLN_TElementPosActionTlEfloatgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map",117,G__get_linked_tagnum(&G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR),0,-1); + G__setnewtype(-1,NULL,0); + G__search_typename2("map >",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"),-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 >" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TObjArray = { "TObjArray" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector >" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator >::iterator>" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator" , 115 , -1 }; +G__linked_taginfo G__AculDataCintLN_TFile = { "TFile" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map,allocator > >" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TH1 = { "TH1" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TVectorTlEfloatgR = { "TVectorT" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TVectorTlEdoublegR = { "TVectorT" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTBaselEfloatgR = { "TMatrixTBase" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTBaselEdoublegR = { "TMatrixTBase" , 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" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TElementPosActionTlEfloatgR = { "TElementPosActionT" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTlEfloatgR = { "TMatrixT" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTRowlEfloatgR = { "TMatrixTRow" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTSublEfloatgR = { "TMatrixTSub" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_ConfigDictionary = { "ConfigDictionary" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgR = { "map,allocator > >" , 99 , -1 }; +G__linked_taginfo G__AculDataCintLN_maplEstringcOstringcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOstringgRsPgRsPgRcLcLiterator = { "map,allocator > >::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; + diff --git a/AculData/AculDataCint.h b/AculData/AculDataCint.h new file mode 100644 index 0000000..260d2a1 --- /dev/null +++ b/AculData/AculDataCint.h @@ -0,0 +1,85 @@ +/******************************************************************** +* /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 +#include +#include +#include +#include +#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 +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 */ diff --git a/AculData/ConfigDictionary.cpp b/AculData/ConfigDictionary.cpp new file mode 100644 index 0000000..81465fd --- /dev/null +++ b/AculData/ConfigDictionary.cpp @@ -0,0 +1,243 @@ +#include "ConfigDictionary.h" + +ClassImp(ConfigDictionary); + +////////////////////////////////////////////////////////////////////////////// +// BEGIN_HTML +//

Config(uration)Dictionary class

+//
+// Author: Bartlomiej Hnatio 2012-08-06 +//

+// 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. +//


+// Most simple example of usage: +//

Suppose you have two variables fD and fI: +// 
-------------------
+//    Double_t fD;
+//    Int_t fI;
+//
+//fD = 3.14;
+//fI = 2012;
+//-----------------------
+// To save its parameters into file you can create ConfigDictionary class +// instance and use SetDouble and SetInt functions to +// insert parameters values with arbitrarly defined keys (let them be +// really long and descriptive in this example): +// 
---------------------
+//ConfigDictionary CD;
+//CD.SetDouble("Most important variable D",fD);
+//CD.SetInt("Equally important integer I",fI);
+//---------------------
+// Now configuration string saved in ConfigDictionary CD +// can be obtained with ToString method and should look like: +//
+//"Most important variable D"="3.14" "Equally important integer I"="2012"
+//
+//
It can be easily saved to a file using simplest fstream +// 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. +//
+//
+// 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: +// 
-----------------
+//"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"
+//(...)
+//----------------
+// 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 FromString method. After this, you can +// extract parameters (using GetDouble and GetInt methods) +// with using same keys as were used for saving, and ConfigDictionary +// will return their values: +// 
----------------------
+//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");
+//--------------------
+//
+// 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 Get 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 Get 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: +//
-------------------
+//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!");
+//}
+//--------------------
+// 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::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<<"\""<first<<"\""<<"="<<"\""<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< +#include +#include +#include "TLorentzVector.h" +#include +#include "TMath.h" +#include "TString.h" +#include "TTree.h" + + +class ConfigDictionary{ +public: + typedef std::map::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 configMap; +}; + +#endif diff --git a/AculData/ReturnCodes.h b/AculData/ReturnCodes.h new file mode 100644 index 0000000..9bf1432 --- /dev/null +++ b/AculData/ReturnCodes.h @@ -0,0 +1,17 @@ +#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 diff --git a/AculData/linkdef.h b/AculData/linkdef.h new file mode 100755 index 0000000..24524d2 --- /dev/null +++ b/AculData/linkdef.h @@ -0,0 +1,13 @@ +#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 + diff --git a/README b/README new file mode 100755 index 0000000..73b0680 --- /dev/null +++ b/README @@ -0,0 +1,9 @@ +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 diff --git a/calibration1.cxx b/calibration1.cxx new file mode 100644 index 0000000..0e25c9f --- /dev/null +++ b/calibration1.cxx @@ -0,0 +1,21 @@ +{ + 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"); + + +} diff --git a/calibration2.cxx b/calibration2.cxx new file mode 100644 index 0000000..4e7134d --- /dev/null +++ b/calibration2.cxx @@ -0,0 +1,33 @@ +{ + 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(); + } + +} diff --git a/calibrationBranch.cxx b/calibrationBranch.cxx new file mode 100644 index 0000000..3765093 --- /dev/null +++ b/calibrationBranch.cxx @@ -0,0 +1,11 @@ +{ + gSystem->Load("~/workspace/Utilities/libAculData.so"); + + TFile fr("clb01_0001.root"); + + TTree *tr = (TTree*)fr.Get("AnalysisxTree"); + + tr->Draw("SQ22[0]", "SQ22[0]>100"); + + +} diff --git a/html.cxx b/html.cxx new file mode 100755 index 0000000..004141c --- /dev/null +++ b/html.cxx @@ -0,0 +1,47 @@ +{ +// 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"); + +} diff --git a/load.cxx b/load.cxx new file mode 100755 index 0000000..c9cd115 --- /dev/null +++ b/load.cxx @@ -0,0 +1,4 @@ +{ + gSystem->Load("~/workspace/Utilities/libAculData.so"); + +} diff --git a/makefile b/makefile new file mode 100755 index 0000000..a2a1de6 --- /dev/null +++ b/makefile @@ -0,0 +1,80 @@ +################################################################################ +# 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 ' ' diff --git a/parforcal.par b/parforcal.par new file mode 100755 index 0000000..0d85974 --- /dev/null +++ b/parforcal.par @@ -0,0 +1,15 @@ +//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 // -- 2.18.1