//
// ROOT includes
//
-#include <iostream>
+
#include <fstream>
-#include <TString.h>
-#include <TRandom.h>
-#include <TLegend.h>
-#include <TLine.h>
-#include <TCanvas.h>
-#include <TROOT.h>
-#include <TStyle.h>
+#include <iostream>
+
+#include <TFile.h>
+#include <TFriendElement.h>
+#include <TGraph.h>
+#include <TKey.h>
+#include <TPad.h>
+//#include <TCanvas.h>
#include <TH1.h>
#include <TH1F.h>
-#include <THashTable.h>
+#include <TLegend.h>
+#include <TLine.h>
+#include <TMath.h>
#include <TObjString.h>
-#include "TTreeStream.h"
-#include "TFile.h"
-#include "TKey.h"
-#include "TGraph.h"
-#include "TDirectory.h"
-#include "AliTPCCalibPulser.h"
-#include "AliTPCCalibPedestal.h"
-#include "AliTPCCalibCE.h"
-#include "TFriendElement.h"
-// #include "TObjArray.h"
-// #include "TObjString.h"
-// #include "TString.h"
-// #include "AliTPCCalPad.h"
+//#include <TROOT.h>
+#include <TRandom.h>
+#include <TString.h>
+#include <TStyle.h>
+#include <TTreeStream.h>
+#include "AliTPCCalibCE.h"
+#include "AliMathBase.h"
+#include "AliTPCCalPad.h"
+#include "AliTPCCalROC.h"
+#include "AliTPCCalibPedestal.h"
+#include "AliTPCCalibPulser.h"
//
// AliRoot includes
//
#include "AliTPCCalibViewer.h"
+using std::ifstream;
ClassImp(AliTPCCalibViewer)
}
//_____________________________________________________________________________
-AliTPCCalibViewer::AliTPCCalibViewer(TTree* tree)
+AliTPCCalibViewer::AliTPCCalibViewer(TTree *const tree)
:TObject(),
fTree(0),
fFile(0),
}
//_____________________________________________________________________________
-AliTPCCalibViewer::AliTPCCalibViewer(char* fileName, char* treeName)
+AliTPCCalibViewer::AliTPCCalibViewer(const char* fileName, const char* treeName)
:TObject(),
fTree(0),
fFile(0),
// assignment operator - dummy
// not yet working!!!
//
+ if (this == ¶m) return (*this);
+
fTree = param.fTree;
fTreeMustBeDeleted = param.fTreeMustBeDeleted;
//fFile = new TFile(*(param.fFile));
}
//_____________________________________________________________________________
-void AliTPCCalibViewer::Delete(Option_t* option) {
+void AliTPCCalibViewer::Delete(Option_t* /*option*/) {
//
// Should be called from AliTPCCalibViewerGUI class only.
// If you use Delete() do not call the destructor.
// All objects (except those contained in fListOfObjectsToBeDeleted) will be deleted, the file will be closed.
//
- option = option; // to avoid warnings on compiling
if (fTree && fTreeMustBeDeleted) {
fTree->SetCacheSize(0);
fTree->Delete();
}
- if (fFile)
- delete fFile;
+ delete fFile;
delete fListOfObjectsToBeDeleted;
}
+
+const char* AliTPCCalibViewer::AddAbbreviations(const Char_t *c, Bool_t printDrawCommand){
+ // Replace all "<variable>" with "<variable><fAbbreviation>" (Adds forgotten "~")
+ // but take care on the statistical information, like "CEQmean_Mean"
+ // and also take care on correct given variables, like "CEQmean~"
+ //
+ // For each variable out of "listOfVariables":
+ // - 'Save' correct items:
+ // - form <replaceString>, take <variable>'s first char, add <removeString>, add rest of <variable>, e.g. "C!#EQmean" (<removeString> = "!#")
+ // - For each statistical information in "listOfNormalizationVariables":
+ // - ReplaceAll <variable><statistical_Information> with <replaceString><statistical_Information>
+ // - ReplaceAll <variable><abbreviation> with <replaceString><abbreviation>, e.g. "CEQmean~" -> "C!#EQmean~"
+ // - ReplaceAll <variable><appendStr> with <replaceString><appendStr>, e.g. "CEQmean.fElements" -> "C!#EQmean.fElements"
+ //
+ // - Do actual replacing:
+ // - ReplaceAll <variable> with <variable><fAbbreviation>, e.g. "CEQmean" -> "CEQmean~"
+ //
+ // - Undo saving:
+ // - For each statistical information in "listOfNormalizationVariables":
+ // - ReplaceAll <replaceString><statistical_Information> with <variable><statistical_Information>
+ // - ReplaceAll <replaceString><abbreviation> with <variable><abbreviation>, e.g. "C!#EQmean~" -> "CEQmean~"
+ // - ReplaceAll <replaceString><appendStr> with <variable><appendStr>, e.g. "C!#EQmean.fElements" -> "CEQmean.fElements"
+ //
+ // Now all the missing "~" should be added.
+
+ TString str(c);
+ TString removeString = "!#"; // very unpropable combination of chars
+ TString replaceString = "";
+ TString searchString = "";
+ TString normString = "";
+ TObjArray *listOfVariables = GetListOfVariables();
+ listOfVariables->Add(new TObjString("channel"));
+ listOfVariables->Add(new TObjString("gx"));
+ listOfVariables->Add(new TObjString("gy"));
+ listOfVariables->Add(new TObjString("lx"));
+ listOfVariables->Add(new TObjString("ly"));
+ listOfVariables->Add(new TObjString("pad"));
+ listOfVariables->Add(new TObjString("row"));
+ listOfVariables->Add(new TObjString("rpad"));
+ listOfVariables->Add(new TObjString("sector"));
+ TObjArray *listOfNormalizationVariables = GetListOfNormalizationVariables();
+ Int_t nVariables = listOfVariables->GetEntriesFast();
+ Int_t nNorm = listOfNormalizationVariables->GetEntriesFast();
+
+ Int_t *varLengths = new Int_t[nVariables];
+ for (Int_t i = 0; i < nVariables; i++) {
+ varLengths[i] = ((TObjString*)listOfVariables->At(i))->String().Length();
+ }
+ Int_t *normLengths = new Int_t[nNorm];
+ for (Int_t i = 0; i < nNorm; i++) {
+ normLengths[i] = ((TObjString*)listOfNormalizationVariables->At(i))->String().Length();
+ // printf("normLengths[%i] (%s) = %i \n", i,((TObjString*)listOfNormalizationVariables->At(i))->String().Data(), normLengths[i]);
+ }
+ Int_t *varSort = new Int_t[nVariables];
+ TMath::Sort(nVariables, varLengths, varSort, kTRUE);
+ Int_t *normSort = new Int_t[nNorm];
+ TMath::Sort(nNorm, normLengths, normSort, kTRUE);
+ // for (Int_t i = 0; i<nNorm; i++) printf("normLengths: %i\n", normLengths[normSort[i]]);
+ // for (Int_t i = 0; i<nVariables; i++) printf("varLengths: %i\n", varLengths[varSort[i]]);
+
+ for (Int_t ivar = 0; ivar < nVariables; ivar++) {
+ // ***** save correct tokens *****
+ // first get the next variable:
+ searchString = ((TObjString*)listOfVariables->At(varSort[ivar]))->String();
+ // printf("searchString: %s ++++++++++++++\n", searchString.Data());
+ // form replaceString:
+ replaceString = "";
+ for (Int_t i = 0; i < searchString.Length(); i++) {
+ replaceString.Append(searchString[i]);
+ if (i == 0) replaceString.Append(removeString);
+ }
+ // go through normalization:
+ // printf("go through normalization\n");
+ for (Int_t inorm = 0; inorm < nNorm; inorm++) {
+ // printf(" inorm=%i, nNorm=%i, normSort[inorm]=%i \n", inorm, nNorm, normSort[inorm]);
+ normString = ((TObjString*)listOfNormalizationVariables->At(normSort[inorm]))->String();
+ // printf(" walking in normalization, i=%i, normString=%s \n", inorm, normString.Data());
+ str.ReplaceAll(searchString + normString, replaceString + normString);
+ // like: str.ReplaceAll("CEQmean_Mean", "C!EQmean_Mean");
+ }
+ str.ReplaceAll(searchString + fAbbreviation, replaceString + fAbbreviation);
+ // like: str.ReplaceAll("CEQmean~", "C!EQmean~");
+ str.ReplaceAll(searchString + fAppendString, replaceString + fAppendString);
+ // like: str.ReplaceAll("CEQmean.fElements", "C!EQmean.fElements");
+
+ // ***** add missing extensions *****
+ str.ReplaceAll(searchString, replaceString + fAbbreviation);
+ // like: str.ReplaceAll("CEQmean", "C!EQmean~");
+ }
+
+ // ***** undo saving *****
+ str.ReplaceAll(removeString, "");
+
+ if (printDrawCommand) std::cout << "The string looks now like: " << str.Data() << std::endl;
+ delete [] varLengths;
+ delete [] normLengths;
+ delete [] varSort;
+ delete [] normSort;
+ return str.Data();
+}
+
+
+
+
//_____________________________________________________________________________
Int_t AliTPCCalibViewer::EasyDraw(const char* drawCommand, const char* sector, const char* cuts, const char* drawOptions, Bool_t writeDrawCommand) const {
//
sectorStr.ToUpper();
TString cutStr("");
//TString drawOptionsStr("profcolz ");
+ Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
+ if (dangerousToDraw) {
+ Warning("EasyDraw", "The draw string must not contain ':' or '>>'. Using only first variable for drawing!");
+// return -1;
+// drawStr.Resize(drawStr.First(">"));
+ drawStr.Resize(drawStr.First(":"));
+ }
+
TString drawOptionsStr("");
TRandom rnd(0);
Int_t rndNumber = rnd.Integer(10000);
drawStr += rndNumber;
drawStr += "(330,-250,250,330,-250,250)";
}
+ else if (sectorStr.Contains("S")) {
+ drawStr += Form(":rpad%s:row%s+(sector>35)*63>>prof", fAppendString.Data(), fAppendString.Data());
+ drawStr += rndNumber;
+ drawStr += "(159,0,159,140,-70,70)";
+ TString sec=sectorStr;
+ sec.Remove(0,1);
+ cutStr += "sector%36=="+sec+" ";
+ }
else if (sectorStr.IsDigit()) {
Int_t isec = sectorStr.Atoi();
drawStr += Form(":rpad%s:row%s>>prof", fAppendString.Data(), fAppendString.Data());
// writeDrawCommand: write the command, that is passed to TTree::Draw
//
if (sector >= 0 && sector < 72) {
- char sectorChr[3];
- sprintf(sectorChr, "%i", sector);
- return EasyDraw(drawCommand, sectorChr, cuts, drawOptions, writeDrawCommand);
+ return EasyDraw(drawCommand, Form("%i", sector), cuts, drawOptions, writeDrawCommand);
}
Error("EasyDraw","The TPC contains only sectors between 0 and 71.");
return -1;
cutStr += isec;
cutStr += ") ";
}
+ else if (sectorStr.Contains("S")) {
+ TString sec=sectorStr;
+ sec.Remove(0,1);
+ cutStr += "sector%36=="+sec+" ";
+ }
if (cuts && cuts[0] != 0) {
if (cutStr.Length() != 0) cutStr += "&& ";
cutStr.ReplaceAll(fAbbreviation, fAppendString);
if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
+ if (returnValue == -1) return -1;
- TObject *obj = gPad->GetPrimitive("htemp");
+ TObject *obj = (gPad) ? gPad->GetPrimitive("htemp") : 0;
if (!obj) obj = (TH1F*)gDirectory->Get("htemp");
if (!obj) obj = gPad->GetPrimitive("tempHist");
if (!obj) obj = (TH1F*)gDirectory->Get("tempHist");
//
if (sector >= 0 && sector < 72) {
- char sectorChr[3];
- sprintf(sectorChr, "%i", sector);
- return EasyDraw1D(drawCommand, sectorChr, cuts, drawOptions, writeDrawCommand);
+ return EasyDraw1D(drawCommand, Form("%i",sector), cuts, drawOptions, writeDrawCommand);
}
Error("EasyDraw","The TPC contains only sectors between 0 and 71.");
return -1;
// "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?
//
if (sector >= 0 && sector < 72) {
- char sectorChr[3];
- sprintf(sectorChr, "%i", sector);
- return DrawHisto1D(drawCommand, sectorChr, cuts, sigmas, plotMean, plotMedian, plotLTM);
+ return DrawHisto1D(drawCommand, Form("%i", sector), cuts, sigmas, plotMean, plotMedian, plotLTM);
}
Error("DrawHisto1D","The TPC contains only sectors between 0 and 71.");
return -1;
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
TString drawStr(drawCommand);
Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
if (dangerousToDraw) {
Double_t sigma = TMath::RMS(entries, values);
Double_t maxY = htemp->GetMaximum();
- char c[500];
TLegend * legend = new TLegend(.7,.7, .99, .99, "Statistical information");
-// sprintf(c, "%s, sector: %i", type, sector);
//fListOfObjectsToBeDeleted->Add(legend);
if (plotMean) {
line->SetLineWidth(2);
line->SetLineStyle(1);
line->Draw();
- sprintf(c, "Mean: %f", mean);
- legend->AddEntry(line, c, "l");
+ legend->AddEntry(line, Form("Mean: %f", mean), "l");
// draw sigma lines
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
TLine* linePlusSigma = new TLine(mean + nsigma[i] * sigma, 0, mean + nsigma[i] * sigma, maxY);
lineMinusSigma->SetLineColor(kRed);
lineMinusSigma->SetLineStyle(2 + i);
lineMinusSigma->Draw();
- sprintf(c, "%i #sigma = %f",(Int_t)(nsigma[i]), (Float_t)(nsigma[i] * sigma));
- legend->AddEntry(lineMinusSigma, c, "l");
+ legend->AddEntry(lineMinusSigma, Form("%i #sigma = %f",(Int_t)(nsigma[i]), (Float_t)(nsigma[i] * sigma)), "l");
}
}
if (plotMedian) {
line->SetLineWidth(2);
line->SetLineStyle(1);
line->Draw();
- sprintf(c, "Median: %f", median);
- legend->AddEntry(line, c, "l");
+ legend->AddEntry(line, Form("Median: %f", median), "l");
// draw sigma lines
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
TLine* linePlusSigma = new TLine(median + nsigma[i] * sigma, 0, median + nsigma[i]*sigma, maxY);
lineMinusSigma->SetLineColor(kBlue);
lineMinusSigma->SetLineStyle(2 + i);
lineMinusSigma->Draw();
- sprintf(c, "%i #sigma = %f",(Int_t)(nsigma[i]), (Float_t)(nsigma[i] * sigma));
- legend->AddEntry(lineMinusSigma, c, "l");
+ legend->AddEntry(lineMinusSigma, Form("%i #sigma = %f",(Int_t)(nsigma[i]), (Float_t)(nsigma[i] * sigma)), "l");
}
}
if (plotLTM) {
line->SetLineWidth(2);
line->SetLineStyle(1);
line->Draw();
- sprintf(c, "LTM: %f", ltm);
- legend->AddEntry(line, c, "l");
+ legend->AddEntry(line, Form("LTM: %f", ltm), "l");
// draw sigma lines
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
TLine* linePlusSigma = new TLine(ltm + nsigma[i] * ltmRms, 0, ltm + nsigma[i] * ltmRms, maxY);
lineMinusSigma->SetLineColor(kGreen+2);
lineMinusSigma->SetLineStyle(2+i);
lineMinusSigma->Draw();
- sprintf(c, "%i #sigma = %f", (Int_t)(nsigma[i]), (Float_t)(nsigma[i] * ltmRms));
- legend->AddEntry(lineMinusSigma, c, "l");
+ legend->AddEntry(lineMinusSigma, Form("%i #sigma = %f", (Int_t)(nsigma[i]), (Float_t)(nsigma[i] * ltmRms)), "l");
}
}
if (!plotMean && !plotMedian && !plotLTM) return -1;
// sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, Begin_Latex t #sigma End_Latex)
// sigmaStep: the binsize of the generated histogram
// Begin_Latex
- // f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx }{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx }
+ // f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx)
// End_Latex
//
//
// plotMean/plotMedian/plotLTM: specifies where to put the center
//
if (sector >= 0 && sector < 72) {
- char sectorChr[3];
- sprintf(sectorChr, "%i", sector);
- return SigmaCut(drawCommand, sectorChr, cuts, sigmaMax, plotMean, plotMedian, plotLTM, pm, sigmas, sigmaStep);
+ return SigmaCut(drawCommand, Form("%i", sector), cuts, sigmaMax, plotMean, plotMedian, plotLTM, pm, sigmas, sigmaStep);
}
Error("SigmaCut","The TPC contains only sectors between 0 and 71.");
return -1;
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
if (plotMean) {
cutHistoMean = AliTPCCalibViewer::SigmaCut(htemp, mean, sigma, sigmaMax, sigmaStep, pm);
if (cutHistoMean) {
cutHistoLTM->SetLineColor(kGreen+2);
legend->AddEntry(cutHistoLTM, "LTM", "l");
cutHistoLTM->SetTitle(Form("%s, cumulative; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
- if (plotMean && cutHistoMean || plotMedian && cutHistoMedian) cutHistoLTM->Draw("same");
+ if ((plotMean && cutHistoMean) || (plotMedian && cutHistoMedian)) cutHistoLTM->Draw("same");
else cutHistoLTM->Draw();
DrawLines(cutHistoLTM, nsigma, legend, kGreen+2, pm);
}
}
-Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t pm, const char *sigmas, Float_t sigmaStep) const {
+Int_t AliTPCCalibViewer::SigmaCutNew(const char* drawCommand, const char* sector, const char* cuts, Float_t /*sigmaMax*/, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, Bool_t /*pm*/, const char *sigmas, Float_t /*sigmaStep*/) const {
//
// Creates a histogram, where you can see, how much of the data are inside sigma-intervals
// around the mean/median/LTM
//
// Double_t ltmFraction = 0.8; //unused
- // avoid compiler warnings:
- sigmaMax = sigmaMax;
- pm = pm;
- sigmaStep = sigmaStep;
TString drawStr(drawCommand);
drawStr += " >> tempHist";
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
+ delete sigmasTokens;
if (plotMean) {
for (Int_t i = 0; i < entries; i++) {
DrawLines(cutGraphMean, nsigma, legend, kRed, kTRUE);
}
}
+ delete [] index;
+ delete [] xarray;
+ delete [] yarray;
/*
if (plotMedian) {
cutHistoMedian = AliTPCCalibViewer::SigmaCut(htemp, median, sigma, sigmaMax, sigmaStep, pm);
// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
// The actual work is done on the array.
/* Begin_Latex
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx}{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx }
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
End_Latex
*/
if (sector >= 0 && sector < 72) {
- char sectorChr[3];
- sprintf(sectorChr, "%i", sector);
- return Integrate(drawCommand, sectorChr, cuts, sigmaMax, plotMean, plotMedian, plotLTM, sigmas, sigmaStep);
+ return Integrate(drawCommand, Form("%i", sector), cuts, sigmaMax, plotMean, plotMedian, plotLTM, sigmas, sigmaStep);
}
Error("Integrate","The TPC contains only sectors between 0 and 71.");
return -1;
// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
// The actual work is done on the array.
/* Begin_Latex
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx}{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx }
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
End_Latex
*/
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
//fListOfObjectsToBeDeleted->Add(legend);
TH1F *integralHistoMean = 0;
integralHistoLTM->SetLineColor(kGreen+2);
legend->AddEntry(integralHistoLTM, "LTM", "l");
integralHistoLTM->SetTitle(Form("%s, integrated; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
- if (plotMean && integralHistoMean || plotMedian && integralHistoMedian) integralHistoLTM->Draw("same");
+ if ((plotMean && integralHistoMean) || (plotMedian && integralHistoMedian)) integralHistoLTM->Draw("same");
else integralHistoLTM->Draw();
DrawLines(integralHistoLTM, nsigma, legend, kGreen+2, kTRUE);
}
}
-Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector, const char* cuts, Float_t sigmaMax, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t sigmaStep) const {
+Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, const char* sector, const char* cuts, Float_t /*sigmaMax*/, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM, const char *sigmas, Float_t /*sigmaStep*/) const {
//
// Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
// "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
// The actual work is done on the array.
/* Begin_Latex
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx}{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx }
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
End_Latex
*/
Double_t ltmFraction = 0.8;
- // avoid compiler warnings:
- sigmaMax = sigmaMax;
- sigmaStep = sigmaStep;
TString drawStr(drawCommand);
Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
nsigma[i] = sig;
}
-
+ delete sigmasTokens;
+
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
//fListOfObjectsToBeDeleted->Add(legend);
integralGraphLTM->SetLineColor(kGreen+2);
legend->AddEntry(integralGraphLTM, "LTM", "l");
integralGraphLTM->SetTitle(Form("%s, integrated; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
- if (plotMean && integralGraphMean || plotMedian && integralGraphMedian) integralGraphLTM->Draw("samelu");
+ if ((plotMean && integralGraphMean) || (plotMedian && integralGraphMedian)) integralGraphLTM->Draw("samelu");
else integralGraphLTM->Draw("alu");
DrawLines(integralGraphLTM, nsigma, legend, kGreen+2, kTRUE);
}
}
+ delete [] index;
+ delete [] xarray;
+ delete [] yarray;
+
if (!plotMean && !plotMedian && !plotLTM) return -1;
legend->Draw();
return entries;
//
// start to draw the lines, loop over requested sigmas
- char c[500];
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
if (!pm) {
Int_t bin = histogram->GetXaxis()->FindBin(nsigma[i]);
lineLeft->SetLineColor(color);
lineLeft->SetLineStyle(2 + i);
lineLeft->Draw();
- sprintf(c, "Fraction(%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin));
- legend->AddEntry(lineLeft, c, "l");
+ legend->AddEntry(lineLeft, Form("Fraction(%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin)), "l");
}
else { // if (pm)
Int_t bin = histogram->GetXaxis()->FindBin(nsigma[i]);
lineLeft1->SetLineColor(color);
lineLeft1->SetLineStyle(2 + i);
lineLeft1->Draw();
- sprintf(c, "Fraction(+%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin));
- legend->AddEntry(lineLeft1, c, "l");
+ legend->AddEntry(lineLeft1, Form("Fraction(+%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin)), "l");
bin = histogram->GetXaxis()->FindBin(-nsigma[i]);
TLine* lineUp2 = new TLine(-nsigma[i], 0, -nsigma[i], histogram->GetBinContent(bin));
//fListOfObjectsToBeDeleted->Add(lineUp2);
lineLeft2->SetLineColor(color);
lineLeft2->SetLineStyle(2 + i);
lineLeft2->Draw();
- sprintf(c, "Fraction(-%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin));
- legend->AddEntry(lineLeft2, c, "l");
+ legend->AddEntry(lineLeft2, Form("Fraction(-%f #sigma) = %f",nsigma[i], histogram->GetBinContent(bin)), "l");
}
} // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
}
//
// start to draw the lines, loop over requested sigmas
- char c[500];
for (Int_t i = 0; i < nsigma.GetNoElements(); i++) {
if (!pm) {
TLine* lineUp = new TLine(nsigma[i], 0, nsigma[i], graph->Eval(nsigma[i]));
lineLeft->SetLineColor(color);
lineLeft->SetLineStyle(2 + i);
lineLeft->Draw();
- sprintf(c, "Fraction(%f #sigma) = %f",nsigma[i], graph->Eval(nsigma[i]));
- legend->AddEntry(lineLeft, c, "l");
+ legend->AddEntry(lineLeft, Form("Fraction(%f #sigma) = %f",nsigma[i], graph->Eval(nsigma[i])), "l");
}
else { // if (pm)
TLine* lineUp1 = new TLine(nsigma[i], 0, nsigma[i], graph->Eval(nsigma[i]));
lineLeft1->SetLineColor(color);
lineLeft1->SetLineStyle(2 + i);
lineLeft1->Draw();
- sprintf(c, "Fraction(+%f #sigma) = %f",nsigma[i], graph->Eval(nsigma[i]));
- legend->AddEntry(lineLeft1, c, "l");
+ legend->AddEntry(lineLeft1, Form("Fraction(+%f #sigma) = %f",nsigma[i], graph->Eval(nsigma[i])), "l");
TLine* lineUp2 = new TLine(-nsigma[i], 0, -nsigma[i], graph->Eval(-nsigma[i]));
//fListOfObjectsToBeDeleted->Add(lineUp2);
lineUp2->SetLineColor(color);
lineLeft2->SetLineColor(color);
lineLeft2->SetLineStyle(2 + i);
lineLeft2->Draw();
- sprintf(c, "Fraction(-%f #sigma) = %f",nsigma[i], graph->Eval(-nsigma[i]));
- legend->AddEntry(lineLeft2, c, "l");
+ legend->AddEntry(lineLeft2, Form("Fraction(-%f #sigma) = %f",nsigma[i], graph->Eval(-nsigma[i])), "l");
}
} // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
}
}
-Double_t AliTPCCalibViewer::GetLTM(Int_t n, Double_t *array, Double_t *sigma, Double_t fraction){
+Double_t AliTPCCalibViewer::GetLTM(Int_t n, const Double_t *const array, Double_t *const sigma, Double_t fraction){
//
// returns the LTM and sigma
//
}
-TH1F* AliTPCCalibViewer::SigmaCut(TH1F *histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm) {
+TH1F* AliTPCCalibViewer::SigmaCut(TH1F *const histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm) {
//
// Creates a cumulative histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
// The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'histogram'
// pm: Decide weather Begin_Latex t > 0 End_Latex (first case) or Begin_Latex t End_Latex arbitrary (secound case)
// The actual work is done on the array.
/* Begin_Latex
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx }{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx } , for t > 0
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = (#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx + #int_{#mu}^{#mu - t #sigma} f(x, #mu, #sigma) dx) / (#int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx), for t > 0
or
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx}{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx }
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{#mu}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
End_Latex
- begin_macro(source)
+ Begin_Macro(source)
{
Float_t mean = 0;
Float_t sigma = 1.5;
Float_t sigmaMax = 4;
gROOT->SetStyle("Plain");
- TH1F *distribution = new TH1F("Distribution1", "Distribution f(x, #mu, #sigma)", 1000,-5,5);
+ TH1F *distribution = new TH1F("Distrib1", "Distribution f(x, #mu, #sigma)", 1000,-5,5);
TRandom rand(23);
for (Int_t i = 0; i <50000;i++) distribution->Fill(rand.Gaus(mean, sigma));
Float_t *ar = distribution->GetArray();
- TCanvas* macro_example_canvas = new TCanvas("macro_example_canvas_SigmaCut", "", 350, 350);
+ TCanvas* macro_example_canvas = new TCanvas("cAliTPCCalibViewer1", "", 350, 350);
macro_example_canvas->Divide(0,3);
TVirtualPad *pad1 = macro_example_canvas->cd(1);
pad1->SetGridy();
shistPM->Draw();
return macro_example_canvas;
}
- end_macro
+ End_Macro
*/
Float_t *array = histogram->GetArray();
}
-TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, Float_t *array, Float_t mean, Float_t sigma, Int_t nbins, Float_t binLow, Float_t binUp, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm){
+TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, const Float_t *array, Float_t mean, Float_t sigma, Int_t nbins, Float_t binLow, Float_t binUp, Float_t sigmaMax, Float_t sigmaStep, Bool_t pm){
//
// Creates a histogram Begin_Latex S(t, #mu, #sigma) End_Latex, where you can see, how much of the data are inside sigma-intervals around the mean value
// The data of the distribution Begin_Latex f(x, #mu, #sigma) End_Latex are given in 'array', 'n' specifies the length of the array
}
-TH1F* AliTPCCalibViewer::SigmaCut(Int_t n, Double_t *array, Double_t mean, Double_t sigma, Int_t nbins, Double_t *xbins, Double_t sigmaMax){
+TH1F* AliTPCCalibViewer::SigmaCut(Int_t /*n*/, const Double_t */*array*/, Double_t /*mean*/, Double_t /*sigma*/, Int_t /*nbins*/, const Double_t */*xbins*/, Double_t /*sigmaMax*/){
//
// SigmaCut for variable binsize
// NOT YET IMPLEMENTED !!!
//
printf("SigmaCut with variable binsize, Not yet implemented\n");
- // avoid compiler warnings:
- n=n;
- mean=mean;
- sigma=sigma;
- nbins=nbins;
- sigmaMax=sigmaMax;
- array=array;
- xbins=xbins;
return 0;
}
-TH1F* AliTPCCalibViewer::Integrate(TH1F *histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
+TH1F* AliTPCCalibViewer::Integrate(TH1F *const histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
//
// Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
// "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
// "sigmaStep": the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
// The actual work is done on the array.
/* Begin_Latex
- f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #frac{#int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx}{ #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx }
+ f(x, #mu, #sigma) #Rightarrow S(t, #mu, #sigma) = #int_{-#infty}^{#mu + t #sigma} f(x, #mu, #sigma) dx / #int_{-#infty}^{+#infty} f(x, #mu, #sigma) dx
End_Latex
- begin_macro(source)
+ Begin_Macro(source)
{
Float_t mean = 0;
Float_t sigma = 1.5;
Float_t sigmaMax = 4;
gROOT->SetStyle("Plain");
- TH1F *distribution = new TH1F("Distribution2", "Distribution f(x, #mu, #sigma)", 1000,-5,5);
+ TH1F *distribution = new TH1F("Distrib2", "Distribution f(x, #mu, #sigma)", 1000,-5,5);
TRandom rand(23);
for (Int_t i = 0; i <50000;i++) distribution->Fill(rand.Gaus(mean, sigma));
Float_t *ar = distribution->GetArray();
- TCanvas* macro_example_canvas = new TCanvas("macro_example_canvas_Integrate", "", 350, 350);
+ TCanvas* macro_example_canvas = new TCanvas("cAliTPCCalibViewer2", "", 350, 350);
macro_example_canvas->Divide(0,2);
TVirtualPad *pad1 = macro_example_canvas->cd(1);
pad1->SetGridy();
shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
shist->Draw();
- return macro_example_canvas_Integrate;
}
- end_macro
+ End_Macro
*/
}
-TH1F* AliTPCCalibViewer::Integrate(Int_t n, Float_t *array, Int_t nbins, Float_t binLow, Float_t binUp, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
+TH1F* AliTPCCalibViewer::Integrate(Int_t n, const Float_t *const array, Int_t nbins, Float_t binLow, Float_t binUp, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep){
// Creates an integrated histogram Begin_Latex S(t, #mu, #sigma) End_Latex, out of the input distribution distribution Begin_Latex f(x, #mu, #sigma) End_Latex, given in "histogram"
// "mean" and "sigma" are Begin_Latex #mu End_Latex and Begin_Latex #sigma End_Latex of the distribution in "histogram", to be specified by the user
// sigmaMax: up to which sigma around the mean/median/LTM you want to integrate
//_____________________________________________________________________________
-AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, char* cuts, char* calPadName) const {
+AliTPCCalPad* AliTPCCalibViewer::GetCalPadOld(const char* desiredData, const char* cuts, const char* calPadName) const {
//
// creates a AliTPCCalPad out of the 'desiredData'
// the functionality of EasyDraw1D is used
AliTPCCalPad * createdCalPad = new AliTPCCalPad(calPadName, calPadName);
Int_t entries = 0;
for (Int_t sec = 0; sec < 72; sec++) {
+ AliTPCCalROC * roc = createdCalPad->GetCalROC(sec);
entries = EasyDraw1D(drawStr.Data(), (Int_t)sec, cuts, "goff");
if (entries == -1) return 0;
+ const Double_t *pchannel = fTree->GetV2();
+ const Double_t *pvalue = fTree->GetV1();
for (Int_t i = 0; i < entries; i++)
- createdCalPad->GetCalROC(sec)->SetValue((UInt_t)(fTree->GetV2()[i]), (Float_t)(fTree->GetV1()[i]));
+ roc->SetValue((UInt_t)(pchannel[i]), (Float_t)(pvalue[i]));
+ }
+ return createdCalPad;
+}
+
+
+//_____________________________________________________________________________
+AliTPCCalPad* AliTPCCalibViewer::GetCalPad(const char* desiredData, const char* cuts, const char* calPadName) const {
+ //
+ // creates a AliTPCCalPad out of the 'desiredData'
+ // the functionality of EasyDraw1D is used
+ // calPadName specifies the name of the created AliTPCCalPad
+ // - this takes a while -
+ //
+ TString drawStr(desiredData);
+ drawStr.Append(":channel.fElements:sector");
+ AliTPCCalPad * createdCalPad = new AliTPCCalPad(calPadName, calPadName);
+ //
+ Int_t entries = fTree->Draw(drawStr, cuts,"goff");
+ const Double_t *pvalue = fTree->GetV1();
+ const Double_t *pchannel = fTree->GetV2();
+ const Double_t *psector = fTree->GetV3();
+
+ for (Int_t ientry=0; ientry<entries; ientry++){
+ Int_t sector= TMath::Nint(psector[ientry]);
+ AliTPCCalROC * roc = createdCalPad->GetCalROC(sector);
+ if (roc) roc->SetValue((UInt_t)(pchannel[ientry]), (Float_t)(pvalue[ientry]));
}
+
+ // for (Int_t sec = 0; sec < 72; sec++) {
+// AliTPCCalROC * roc = createdCalPad->GetCalROC(sec);
+// entries = EasyDraw1D(drawStr.Data(), (Int_t)sec, cuts, "goff");
+// if (entries == -1) return 0;
+// for (Int_t i = 0; i < entries; i++)
+// roc->SetValue((UInt_t)(pchannel[i]), (Float_t)(pvalue[i]));
+// }
return createdCalPad;
}
//_____________________________________________________________________________
-AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t sector, char* cuts) const {
+AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t sector, const char* cuts) const {
//
// creates a AliTPCCalROC out of the desiredData
// the functionality of EasyDraw1D is used
// sector specifies the sector of the created AliTPCCalROC
//
TString drawStr(desiredData);
- drawStr.Append(Form(":channel%s", fAbbreviation.Data()));
+ drawStr.Append(":channel");
+ drawStr.Append(fAbbreviation);
Int_t entries = EasyDraw1D(drawStr.Data(), (Int_t)sector, cuts, "goff");
if (entries == -1) return 0;
AliTPCCalROC * createdROC = new AliTPCCalROC(sector);
//
TObjArray* arr = new TObjArray();
TObjString* str = 0;
+ if (!fTree) return 0;
Int_t nentries = fTree->GetListOfBranches()->GetEntries();
for (Int_t i = 0; i < nentries; i++) {
str = new TObjString(fTree->GetListOfBranches()->At(i)->GetName());
fitter->ClearPoints();
Int_t entries = Draw(drawStr.Data(), cutStr.Data(), "goff");
- if (entries == -1) return new TString("An ERROR has occured during fitting!");
+ if (entries == -1) {
+ delete formulaTokens;
+ return new TString("An ERROR has occured during fitting!");
+ }
Double_t **values = new Double_t*[dim+1] ;
for (Int_t i = 0; i < dim + 1; i++){
if (i < dim) centries = fTree->Draw(((TObjString*)formulaTokens->At(i))->GetName(), cutStr.Data(), "goff");
else centries = fTree->Draw(drawStr.Data(), cutStr.Data(), "goff");
- if (entries != centries) return new TString("An ERROR has occured during fitting!");
+ if (entries != centries) {
+ delete [] values;
+ delete formulaTokens;
+ return new TString("An ERROR has occured during fitting!");
+ }
values[i] = new Double_t[entries];
memcpy(values[i], fTree->GetV1(), entries*sizeof(Double_t));
}
fitter->GetParameters(fitParam);
fitter->GetCovarianceMatrix(covMatrix);
chi2 = fitter->GetChisquare();
- chi2 = chi2;
+// chi2 = chi2;
- TString *preturnFormula = new TString(Form("( %f+",fitParam[0])), &returnFormula = *preturnFormula;
+ TString *preturnFormula = new TString(Form("( %e+",fitParam[0])), &returnFormula = *preturnFormula;
for (Int_t iparam = 0; iparam < dim; iparam++) {
- returnFormula.Append(Form("%s*(%f)",((TObjString*)formulaTokens->At(iparam))->GetName(),fitParam[iparam+1]));
+ returnFormula.Append(Form("%s*(%e)",((TObjString*)formulaTokens->At(iparam))->GetName(),fitParam[iparam+1]));
if (iparam < dim-1) returnFormula.Append("+");
}
returnFormula.Append(" )");
delete formulaTokens;
delete fitter;
- delete[] values;
+ for (Int_t i = 0; i < dim + 1; i++){
+ delete [] values[i];
+ }
+ delete [] values;
return preturnFormula;
}
-void AliTPCCalibViewer::MakeTreeWithObjects(const char * fileName, TObjArray * array, const char * mapFileName) {
+void AliTPCCalibViewer::MakeTreeWithObjects(const char *fileName, const TObjArray *const array, const char * mapFileName) {
//
// Write tree with all available information
// im mapFileName is speciefied, the Map information are also written to the tree
}
-void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad* outlierPad, Float_t ltmFraction) {
+void AliTPCCalibViewer::MakeTree(const char * fileName, TObjArray * array, const char * mapFileName, AliTPCCalPad *const outlierPad, Float_t ltmFraction) {
//
// Write a tree with all available information
// if mapFileName is speciefied, the Map information are also written to the tree
//
// The tree out of this function is the basis for the AliTPCCalibViewer and the AliTPCCalibViewerGUI.
- AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
+ AliTPCROC* tpcROCinstance = AliTPCROC::Instance();
- TObjArray* mapIROCs = 0;
- TObjArray* mapOROCs = 0;
- TVectorF *mapIROCArray = 0;
- TVectorF *mapOROCArray = 0;
- Int_t mapEntries = 0;
- TString* mapNames = 0;
-
- if (mapFileName) {
- TFile mapFile(mapFileName, "read");
-
- TList* listOfROCs = mapFile.GetListOfKeys();
- mapEntries = listOfROCs->GetEntries()/2;
- mapIROCs = new TObjArray(mapEntries*2);
- mapOROCs = new TObjArray(mapEntries*2);
- mapIROCArray = new TVectorF[mapEntries];
- mapOROCArray = new TVectorF[mapEntries];
-
- mapNames = new TString[mapEntries];
- for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
- TString rocName(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
- rocName.Remove(rocName.Length()-4, 4);
- mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "IROC").Data()), ivalue);
- mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "OROC").Data()), ivalue);
- mapNames[ivalue].Append(rocName);
- }
-
- for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
- mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
- mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
+ TObjArray* mapIROCs = 0;
+ TObjArray* mapOROCs = 0;
+ TVectorF *mapIROCArray = 0;
+ TVectorF *mapOROCArray = 0;
+ Int_t mapEntries = 0;
+ TString* mapNames = 0;
+
+ if (mapFileName) {
+ TFile mapFile(mapFileName, "read");
+
+ TList* listOfROCs = mapFile.GetListOfKeys();
+ mapEntries = listOfROCs->GetEntries()/2;
+ mapIROCs = new TObjArray(mapEntries*2);
+ mapOROCs = new TObjArray(mapEntries*2);
+ mapIROCArray = new TVectorF[mapEntries];
+ mapOROCArray = new TVectorF[mapEntries];
+
+ mapNames = new TString[mapEntries];
+ for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
+ TString rocName(((TKey*)(listOfROCs->At(ivalue*2)))->GetName());
+ rocName.Remove(rocName.Length()-4, 4);
+ mapIROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "IROC").Data()), ivalue);
+ mapOROCs->AddAt((AliTPCCalROC*)mapFile.Get((rocName + "OROC").Data()), ivalue);
+ mapNames[ivalue].Append(rocName);
+ }
+
+ for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
+ mapIROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(0));
+ mapOROCArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(36));
- for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
- (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
- for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
- (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
- }
-
- } // if (mapFileName)
+ for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(0); ichannel++)
+ (mapIROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapIROCs->At(ivalue)))->GetValue(ichannel);
+ for (UInt_t ichannel = 0; ichannel < tpcROCinstance->GetNChannels(36); ichannel++)
+ (mapOROCArray[ivalue])[ichannel] = ((AliTPCCalROC*)(mapOROCs->At(ivalue)))->GetValue(ichannel);
+ }
+
+ } // if (mapFileName)
- TTreeSRedirector cstream(fileName);
- Int_t arrayEntries = 0;
- if (array) arrayEntries = array->GetEntries();
-
- TString* names = new TString[arrayEntries];
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
- names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
-
- for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
+ TTreeSRedirector cstream(fileName,"recreate");
+ Int_t arrayEntries = 0;
+ if (array) arrayEntries = array->GetEntries();
+
+ TString* names = new TString[arrayEntries];
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
+ names[ivalue].Append(((AliTPCCalPad*)array->At(ivalue))->GetName());
+
+ for (UInt_t isector = 0; isector < tpcROCinstance->GetNSectors(); isector++) {
//
// get statistic for given sector
//
- TVectorF median(arrayEntries);
- TVectorF mean(arrayEntries);
- TVectorF rms(arrayEntries);
- TVectorF ltm(arrayEntries);
- TVectorF ltmrms(arrayEntries);
- TVectorF medianWithOut(arrayEntries);
- TVectorF meanWithOut(arrayEntries);
- TVectorF rmsWithOut(arrayEntries);
- TVectorF ltmWithOut(arrayEntries);
- TVectorF ltmrmsWithOut(arrayEntries);
-
- TVectorF *vectorArray = new TVectorF[arrayEntries];
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++)
- vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
- AliTPCCalROC* calROC = calPad->GetCalROC(isector);
- AliTPCCalROC* outlierROC = 0;
- if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
- if (calROC) {
- median[ivalue] = calROC->GetMedian();
- mean[ivalue] = calROC->GetMean();
- rms[ivalue] = calROC->GetRMS();
- Double_t ltmrmsValue = 0;
- ltm[ivalue] = calROC->GetLTM(<mrmsValue, ltmFraction);
- ltmrms[ivalue] = ltmrmsValue;
- if (outlierROC) {
- medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
- meanWithOut[ivalue] = calROC->GetMean(outlierROC);
- rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
- ltmrmsValue = 0;
- ltmWithOut[ivalue] = calROC->GetLTM(<mrmsValue, ltmFraction, outlierROC);
- ltmrmsWithOut[ivalue] = ltmrmsValue;
- }
- }
- else {
- median[ivalue] = 0.;
- mean[ivalue] = 0.;
- rms[ivalue] = 0.;
- ltm[ivalue] = 0.;
- ltmrms[ivalue] = 0.;
- medianWithOut[ivalue] = 0.;
- meanWithOut[ivalue] = 0.;
- rmsWithOut[ivalue] = 0.;
- ltmWithOut[ivalue] = 0.;
- ltmrmsWithOut[ivalue] = 0.;
- }
+ TVectorF median(arrayEntries);
+ TVectorF mean(arrayEntries);
+ TVectorF rms(arrayEntries);
+ TVectorF ltm(arrayEntries);
+ TVectorF ltmrms(arrayEntries);
+ TVectorF medianWithOut(arrayEntries);
+ TVectorF meanWithOut(arrayEntries);
+ TVectorF rmsWithOut(arrayEntries);
+ TVectorF ltmWithOut(arrayEntries);
+ TVectorF ltmrmsWithOut(arrayEntries);
+
+ TVectorF *vectorArray = new TVectorF[arrayEntries];
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++){
+ vectorArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
+ vectorArray[ivalue].SetUniqueID(array->UncheckedAt(ivalue)->GetUniqueID());
+// printf("UniqueID: %d\n",vectorArray[ivalue].GetUniqueID());
+ }
+
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
+ AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
+ AliTPCCalROC* calROC = calPad->GetCalROC(isector);
+ AliTPCCalROC* outlierROC = 0;
+ if (outlierPad) outlierROC = outlierPad->GetCalROC(isector);
+ if (calROC) {
+ median[ivalue] = calROC->GetMedian();
+ mean[ivalue] = calROC->GetMean();
+ rms[ivalue] = calROC->GetRMS();
+ Double_t ltmrmsValue = 0;
+ ltm[ivalue] = calROC->GetLTM(<mrmsValue, ltmFraction);
+ ltmrms[ivalue] = ltmrmsValue;
+ if (outlierROC) {
+ medianWithOut[ivalue] = calROC->GetMedian(outlierROC);
+ meanWithOut[ivalue] = calROC->GetMean(outlierROC);
+ rmsWithOut[ivalue] = calROC->GetRMS(outlierROC);
+ ltmrmsValue = 0;
+ ltmWithOut[ivalue] = calROC->GetLTM(<mrmsValue, ltmFraction, outlierROC);
+ ltmrmsWithOut[ivalue] = ltmrmsValue;
+ }
}
-
+ else {
+ median[ivalue] = 0.;
+ mean[ivalue] = 0.;
+ rms[ivalue] = 0.;
+ ltm[ivalue] = 0.;
+ ltmrms[ivalue] = 0.;
+ medianWithOut[ivalue] = 0.;
+ meanWithOut[ivalue] = 0.;
+ rmsWithOut[ivalue] = 0.;
+ ltmWithOut[ivalue] = 0.;
+ ltmrmsWithOut[ivalue] = 0.;
+ }
+ }
+
//
// fill vectors of variable per pad
//
- TVectorF *posArray = new TVectorF[8];
- for (Int_t ivalue = 0; ivalue < 8; ivalue++)
- posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
-
- Float_t posG[3] = {0};
- Float_t posL[3] = {0};
- Int_t ichannel = 0;
- for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
- for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
- tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
- tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
- posArray[0][ichannel] = irow;
- posArray[1][ichannel] = ipad;
- posArray[2][ichannel] = posL[0];
- posArray[3][ichannel] = posL[1];
- posArray[4][ichannel] = posG[0];
- posArray[5][ichannel] = posG[1];
- posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
- posArray[7][ichannel] = ichannel;
-
+ TVectorF *posArray = new TVectorF[8];
+ for (Int_t ivalue = 0; ivalue < 8; ivalue++)
+ posArray[ivalue].ResizeTo(tpcROCinstance->GetNChannels(isector));
+
+ Float_t posG[3] = {0};
+ Float_t posL[3] = {0};
+ Int_t ichannel = 0;
+ for (UInt_t irow = 0; irow < tpcROCinstance->GetNRows(isector); irow++) {
+ for (UInt_t ipad = 0; ipad < tpcROCinstance->GetNPads(isector, irow); ipad++) {
+ tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
+ tpcROCinstance->GetPositionGlobal(isector, irow, ipad, posG);
+ posArray[0][ichannel] = irow;
+ posArray[1][ichannel] = ipad;
+ posArray[2][ichannel] = posL[0];
+ posArray[3][ichannel] = posL[1];
+ posArray[4][ichannel] = posG[0];
+ posArray[5][ichannel] = posG[1];
+ posArray[6][ichannel] = (Int_t)(ipad - (Double_t)(tpcROCinstance->GetNPads(isector, irow))/2);
+ posArray[7][ichannel] = ichannel;
+
// loop over array containing AliTPCCalPads
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
- AliTPCCalROC* calROC = calPad->GetCalROC(isector);
- if (calROC)
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
+ AliTPCCalPad* calPad = (AliTPCCalPad*) array->At(ivalue);
+ AliTPCCalROC* calROC = calPad->GetCalROC(isector);
+ if (calROC)
(vectorArray[ivalue])[ichannel] = calROC->GetValue(irow, ipad);
- else
- (vectorArray[ivalue])[ichannel] = 0;
- }
- ichannel++;
- }
+ else
+ (vectorArray[ivalue])[ichannel] = 0;
+ }
+ ichannel++;
}
-
- cstream << "calPads" <<
- "sector=" << isector;
-
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- cstream << "calPads" <<
- (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
- (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
- (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
- if (outlierPad) {
- cstream << "calPads" <<
- (Char_t*)((names[ivalue] + "_Median_OutlierCutted=").Data()) << medianWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_Mean_OutlierCutted=").Data()) << meanWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS_OutlierCutted=").Data()) << rmsWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_LTM_OutlierCutted=").Data()) << ltmWithOut[ivalue] <<
- (Char_t*)((names[ivalue] + "_RMS_LTM_OutlierCutted=").Data()) << ltmrmsWithOut[ivalue];
- }
+ }
+
+ cstream << "calPads" <<
+ "sector=" << isector;
+
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
+ if (outlierPad==0) {
+ cstream << "calPads" <<
+ (Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
+ (Char_t*)((names[ivalue] + "_Mean=").Data()) << mean[ivalue] <<
+ (Char_t*)((names[ivalue] + "_RMS=").Data()) << rms[ivalue] <<
+ (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltm[ivalue] <<
+ (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrms[ivalue];
}
-
- for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
- cstream << "calPads" <<
- (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
+ if (outlierPad) {
+ cstream << "calPads" <<
+ (Char_t*)((names[ivalue] + "_Median=").Data()) << medianWithOut[ivalue] <<
+ (Char_t*)((names[ivalue] + "_Mean").Data()) << meanWithOut[ivalue] <<
+ (Char_t*)((names[ivalue] + "_RMS=").Data()) << rmsWithOut[ivalue] <<
+ (Char_t*)((names[ivalue] + "_LTM=").Data()) << ltmWithOut[ivalue] <<
+ (Char_t*)((names[ivalue] + "_RMS_LTM=").Data()) << ltmrmsWithOut[ivalue];
}
-
- if (mapFileName) {
- for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
+ //timestamp and run, if given in title
+ /* TString title(((AliTPCCalPad*) array->At(ivalue))->GetTitle());
+ TObjArray *arrtitle=title.Tokenize(",");
+ Int_t run=-1;
+ UInt_t time=0;
+ TIter next(arrtitle);
+ TObject *o=0;
+ while ( (o=next()) ){
+ TString &entry=((TObjString*)o)->GetString();
+ entry.Remove(TString::kBoth,' ');
+ entry.Remove(TString::kBoth,'\t');
+ if (entry.BeginsWith("Run:")) {
+ run=entry(4,entry.Length()).Atoi();
+ } else if (entry.BeginsWith("Time:")) {
+ time=entry(6,entry.Length()).Atoi();
+ }
+ }
+ delete arrtitle;*/
+
+ }
+
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
+ cstream << "calPads" <<
+ (Char_t*)((names[ivalue] + ".=").Data()) << &vectorArray[ivalue];
+ }
+
+ if (mapFileName) {
+ for (Int_t ivalue = 0; ivalue < mapEntries; ivalue++) {
if (isector < 36)
- cstream << "calPads" <<
- (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
+ cstream << "calPads" <<
+ (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapIROCArray[ivalue];
else
- cstream << "calPads" <<
- (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
+ cstream << "calPads" <<
+ (Char_t*)((mapNames[ivalue] + ".=").Data()) << &mapOROCArray[ivalue];
}
- }
-
- cstream << "calPads" <<
- "row.=" << &posArray[0] <<
- "pad.=" << &posArray[1] <<
- "lx.=" << &posArray[2] <<
- "ly.=" << &posArray[3] <<
- "gx.=" << &posArray[4] <<
- "gy.=" << &posArray[5] <<
- "rpad.=" << &posArray[6] <<
- "channel.=" << &posArray[7];
-
- cstream << "calPads" <<
- "\n";
-
- delete[] posArray;
- delete[] vectorArray;
- }
-
-
- delete[] names;
- if (mapFileName) {
- delete mapIROCs;
- delete mapOROCs;
- delete[] mapIROCArray;
- delete[] mapOROCArray;
- delete[] mapNames;
- }
+ }
+
+ cstream << "calPads" <<
+ "row.=" << &posArray[0] <<
+ "pad.=" << &posArray[1] <<
+ "lx.=" << &posArray[2] <<
+ "ly.=" << &posArray[3] <<
+ "gx.=" << &posArray[4] <<
+ "gy.=" << &posArray[5] <<
+ "rpad.=" << &posArray[6] <<
+ "channel.=" << &posArray[7];
+
+ cstream << "calPads" <<
+ "\n";
+
+ delete[] posArray;
+ delete[] vectorArray;
+ }
+ TTree * tree = (cstream << "calPads").GetTree();
+ MakeCalPadAliases(tree);
+ for (Int_t ivalue = 0; ivalue < arrayEntries; ivalue++) {
+ //(Char_t*)((names[ivalue] + "_Median=").Data()) << median[ivalue] <<
+ tree->SetAlias(TString::Format("%s_LTMRatio",names[ivalue].Data()).Data(), TString::Format("%s.fElements/%s_LTM",names[ivalue].Data(),names[ivalue].Data()).Data());
+ tree->SetAlias(TString::Format("%s_MeanRatio",names[ivalue].Data()).Data(), TString::Format("%s.fElements/%s_Mean",names[ivalue].Data(),names[ivalue].Data()).Data());
+ tree->SetAlias(TString::Format("%s_MedianRatio",names[ivalue].Data()).Data(), TString::Format("%s.fElements/%s_Median",names[ivalue].Data(),names[ivalue].Data()).Data());
+ tree->SetAlias(names[ivalue].Data(), TString::Format("%s.fElements",names[ivalue].Data()).Data());
+ }
+ delete[] names;
+ if (mapFileName) {
+ delete mapIROCs;
+ delete mapOROCs;
+ delete[] mapIROCArray;
+ delete[] mapOROCArray;
+ delete[] mapNames;
+ }
+}
+void AliTPCCalibViewer::MakeCalPadAliases(TTree * tree){
+ //
+ // make standard aliases for standard calibration trees
+ //
+ tree->SetAlias("Pad0","MapPadLength.fElements==7.5"); // pad types
+ tree->SetAlias("Pad1","MapPadLength.fElements==10.0");
+ tree->SetAlias("Pad2","MapPadLength.fElements==15.0");
+ tree->SetAlias("ly","(ly.fElements+((sector<36)*(2*((sector%36)<18)-1)*0.2)+((sector>=36)*(2*((sector%36)<18)-1)*0.3))"); // correction for bug in tpcROCinstance->GetPositionLocal(isector, irow, ipad, posL);
+ tree->SetAlias("dRowNorm0","(row.fElements/32-1)"); // normalized distance to the center of the chamber in lx (-1,1)
+ tree->SetAlias("dRowNorm1","(row.fElements/32-1)"); //
+ tree->SetAlias("dRowNorm2","((row.fElements-63)/16-1)"); //
+ tree->SetAlias("dRowNorm","(row.fElements<63)*(row.fElements/32-1)+(row.fElements>63)*((row.fElements-63)/16-1)");
+ tree->SetAlias("dPhiNorm","(ly/lx.fElements)/(pi/18)"); // normalized distance to the center of the chamber in phi (-1,1)
+ //
+ tree->SetAlias("fsector","(sector%36)+(0.5+9*atan2(ly,lx.fElements)/pi)"); // float sector number
+ tree->SetAlias("posEdge","((pi/18.)-abs(atan(ly/lx.fElements)))*lx.fElements"); //distance to the edge
+ tree->SetAlias("lphi","atan(ly/lx.fElements)"); //local phi angle
}
-
void AliTPCCalibViewer::MakeTree(const char *outPutFileName, const Char_t *inputFileName, AliTPCCalPad *outlierPad, Float_t ltmFraction, const char *mapFileName ){
//
}
delete fIn;
}
+ delete arrFileLine;
}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff