// ROOT includes
//
#include <iostream>
+#include <fstream>
#include <TString.h>
#include <TRandom.h>
#include <TLegend.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"
//
ClassImp(AliTPCCalibViewer)
+
AliTPCCalibViewer::AliTPCCalibViewer()
:TObject(),
fTree(0),
fFile(0),
fListOfObjectsToBeDeleted(0),
- fTreeMustBeDeleted(0)
+ fTreeMustBeDeleted(0),
+ fAbbreviation(0),
+ fAppendString(0)
{
//
// Default constructor
fTree(0),
fFile(0),
fListOfObjectsToBeDeleted(0),
- fTreeMustBeDeleted(0)
+ fTreeMustBeDeleted(0),
+ fAbbreviation(0),
+ fAppendString(0)
{
//
// dummy AliTPCCalibViewer copy constructor
fTreeMustBeDeleted = c.fTreeMustBeDeleted;
//fFile = new TFile(*(c.fFile));
fListOfObjectsToBeDeleted = c.fListOfObjectsToBeDeleted;
+ fAbbreviation = c.fAbbreviation;
+ fAppendString = c.fAppendString;
}
//_____________________________________________________________________________
fTree(0),
fFile(0),
fListOfObjectsToBeDeleted(0),
- fTreeMustBeDeleted(0)
+ fTreeMustBeDeleted(0),
+ fAbbreviation(0),
+ fAppendString(0)
{
//
// Constructor that initializes the calibration viewer
fTree = tree;
fTreeMustBeDeleted = kFALSE;
fListOfObjectsToBeDeleted = new TObjArray();
+ fAbbreviation = "~";
+ fAppendString = ".fElements";
}
//_____________________________________________________________________________
-AliTPCCalibViewer::AliTPCCalibViewer(char* fileName, char* treeName)
+AliTPCCalibViewer::AliTPCCalibViewer(const char* fileName, const char* treeName)
:TObject(),
fTree(0),
fFile(0),
fListOfObjectsToBeDeleted(0),
- fTreeMustBeDeleted(0)
+ fTreeMustBeDeleted(0),
+ fAbbreviation(0),
+ fAppendString(0)
+
{
//
// Constructor to initialize the calibration viewer
fTree = (TTree*) fFile->Get(treeName);
fTreeMustBeDeleted = kTRUE;
fListOfObjectsToBeDeleted = new TObjArray();
+ fAbbreviation = "~";
+ fAppendString = ".fElements";
}
//____________________________________________________________________________
fTreeMustBeDeleted = param.fTreeMustBeDeleted;
//fFile = new TFile(*(param.fFile));
fListOfObjectsToBeDeleted = param.fListOfObjectsToBeDeleted;
+ fAbbreviation = param.fAbbreviation;
+ fAppendString = param.fAppendString;
return (*this);
}
delete fListOfObjectsToBeDeleted;
}
+
+const char* AliTPCCalibViewer::AddAbbreviations(char* 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 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);
drawOptionsStr += "profcolz";
if (sectorStr == "A") {
- drawStr += ":gy.fElements:gx.fElements>>prof";
+ drawStr += Form(":gy%s:gx%s>>prof", fAppendString.Data(), fAppendString.Data());
drawStr += rndNumber;
drawStr += "(330,-250,250,330,-250,250)";
cutStr += "(sector/18)%2==0 ";
}
else if (sectorStr == "C") {
- drawStr += ":gy.fElements:gx.fElements>>prof";
+ drawStr += Form(":gy%s:gx%s>>prof", fAppendString.Data(), fAppendString.Data());
drawStr += rndNumber;
drawStr += "(330,-250,250,330,-250,250)";
cutStr += "(sector/18)%2==1 ";
}
else if (sectorStr == "ALL") {
- drawStr += ":gy.fElements:gx.fElements>>prof";
+ drawStr += Form(":gy%s:gx%s>>prof", fAppendString.Data(), fAppendString.Data());
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 += ":rpad.fElements:row.fElements>>prof";
+ drawStr += Form(":rpad%s:row%s>>prof", fAppendString.Data(), fAppendString.Data());
drawStr += rndNumber;
if (isec < 36 && isec >= 0)
drawStr += "(63,0,63,108,-54,54)";
cutStr += cuts;
cutStr += ")";
}
- drawStr.ReplaceAll("~", ".fElements");
- cutStr.ReplaceAll("~", ".fElements");
+ drawStr.ReplaceAll(fAbbreviation, fAppendString);
+ cutStr.ReplaceAll(fAbbreviation, fAppendString);
if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
- return fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
+ Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
+ TString profName("prof");
+ profName += rndNumber;
+ TObject *obj = gDirectory->Get(profName.Data());
+ if (obj && obj->InheritsFrom("TH1")) FormatHistoLabels((TH1*)obj);
+ return returnValue;
}
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 += ")";
}
- drawStr.ReplaceAll("~", ".fElements");
- cutStr.ReplaceAll("~", ".fElements");
+ drawStr.ReplaceAll(fAbbreviation, fAppendString);
+ cutStr.ReplaceAll(fAbbreviation, fAppendString);
if (writeDrawCommand) std::cout << "fTree->Draw(\"" << drawStr << "\", \"" << cutStr << "\", \"" << drawOptionsStr << "\");" << std::endl;
- return fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
+ Int_t returnValue = fTree->Draw(drawStr.Data(), cutStr.Data(), drawOptionsStr.Data());
+ if (returnValue == -1) return -1;
+
+ 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 (!obj) obj = gPad->GetPrimitive("Graph");
+ if (!obj) obj = (TH1F*)gDirectory->Get("Graph");
+ if (obj && obj->InheritsFrom("TH1")) FormatHistoLabels((TH1*)obj);
+ return returnValue;
}
}
+void AliTPCCalibViewer::FormatHistoLabels(TH1 *histo) const {
+ //
+ // formats title and axis labels of histo
+ // removes '.fElements'
+ //
+ if (!histo) return;
+ TString replaceString(fAppendString.Data());
+ TString *str = new TString(histo->GetTitle());
+ str->ReplaceAll(replaceString, "");
+ histo->SetTitle(str->Data());
+ delete str;
+ if (histo->GetXaxis()) {
+ str = new TString(histo->GetXaxis()->GetTitle());
+ str->ReplaceAll(replaceString, "");
+ histo->GetXaxis()->SetTitle(str->Data());
+ delete str;
+ }
+ if (histo->GetYaxis()) {
+ str = new TString(histo->GetYaxis()->GetTitle());
+ str->ReplaceAll(replaceString, "");
+ histo->GetYaxis()->SetTitle(str->Data());
+ delete str;
+ }
+ if (histo->GetZaxis()) {
+ str = new TString(histo->GetZaxis()->GetTitle());
+ str->ReplaceAll(replaceString, "");
+ histo->GetZaxis()->SetTitle(str->Data());
+ delete str;
+ }
+}
+
+
Int_t AliTPCCalibViewer::DrawHisto1D(const char* drawCommand, Int_t sector, const char* cuts, const char *sigmas, Bool_t plotMean, Bool_t plotMedian, Bool_t plotLTM) const {
//
// Easy drawing of data, in principle the same as EasyDraw1D
}
TString drawStr(drawCommand);
+ Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
+ if (dangerousToDraw) {
+ Warning("DrawHisto1D", "The draw string must not contain ':' or '>>'.");
+ return -1;
+ }
drawStr += " >> tempHist";
Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts);
TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
char c[500];
TLegend * legend = new TLegend(.7,.7, .99, .99, "Statistical information");
// sprintf(c, "%s, sector: %i", type, sector);
- fListOfObjectsToBeDeleted->Add(legend);
+ //fListOfObjectsToBeDeleted->Add(legend);
if (plotMean) {
// draw Mean
TLine* line = new TLine(mean, 0, mean, maxY);
- fListOfObjectsToBeDeleted->Add(line);
+ //fListOfObjectsToBeDeleted->Add(line);
line->SetLineColor(kRed);
line->SetLineWidth(2);
line->SetLineStyle(1);
// 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);
- fListOfObjectsToBeDeleted->Add(linePlusSigma);
+ //fListOfObjectsToBeDeleted->Add(linePlusSigma);
linePlusSigma->SetLineColor(kRed);
linePlusSigma->SetLineStyle(2 + i);
linePlusSigma->Draw();
TLine* lineMinusSigma = new TLine(mean - nsigma[i] * sigma, 0, mean - nsigma[i] * sigma, maxY);
- fListOfObjectsToBeDeleted->Add(lineMinusSigma);
+ //fListOfObjectsToBeDeleted->Add(lineMinusSigma);
lineMinusSigma->SetLineColor(kRed);
lineMinusSigma->SetLineStyle(2 + i);
lineMinusSigma->Draw();
if (plotMedian) {
// draw median
TLine* line = new TLine(median, 0, median, maxY);
- fListOfObjectsToBeDeleted->Add(line);
+ //fListOfObjectsToBeDeleted->Add(line);
line->SetLineColor(kBlue);
line->SetLineWidth(2);
line->SetLineStyle(1);
// 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);
- fListOfObjectsToBeDeleted->Add(linePlusSigma);
+ //fListOfObjectsToBeDeleted->Add(linePlusSigma);
linePlusSigma->SetLineColor(kBlue);
linePlusSigma->SetLineStyle(2 + i);
linePlusSigma->Draw();
TLine* lineMinusSigma = new TLine(median - nsigma[i] * sigma, 0, median - nsigma[i]*sigma, maxY);
- fListOfObjectsToBeDeleted->Add(lineMinusSigma);
+ //fListOfObjectsToBeDeleted->Add(lineMinusSigma);
lineMinusSigma->SetLineColor(kBlue);
lineMinusSigma->SetLineStyle(2 + i);
lineMinusSigma->Draw();
Double_t ltmRms = 0;
Double_t ltm = GetLTM(entries, values, <mRms, ltmFraction);
TLine* line = new TLine(ltm, 0, ltm, maxY);
- fListOfObjectsToBeDeleted->Add(line);
+ //fListOfObjectsToBeDeleted->Add(line);
line->SetLineColor(kGreen+2);
line->SetLineWidth(2);
line->SetLineStyle(1);
// 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);
- fListOfObjectsToBeDeleted->Add(linePlusSigma);
+ //fListOfObjectsToBeDeleted->Add(linePlusSigma);
linePlusSigma->SetLineColor(kGreen+2);
linePlusSigma->SetLineStyle(2+i);
linePlusSigma->Draw();
TLine* lineMinusSigma = new TLine(ltm - nsigma[i] * ltmRms, 0, ltm - nsigma[i] * ltmRms, maxY);
- fListOfObjectsToBeDeleted->Add(lineMinusSigma);
+ //fListOfObjectsToBeDeleted->Add(lineMinusSigma);
lineMinusSigma->SetLineColor(kGreen+2);
lineMinusSigma->SetLineStyle(2+i);
lineMinusSigma->Draw();
Double_t ltmFraction = 0.8;
TString drawStr(drawCommand);
+ Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
+ if (dangerousToDraw) {
+ Warning("SigmaCut", "The draw string must not contain ':' or '>>'.");
+ return -1;
+ }
drawStr += " >> tempHist";
Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
Double_t sigma = TMath::RMS(entries, values);
TLegend * legend = new TLegend(.7,.7, .99, .99, "Cumulative");
- fListOfObjectsToBeDeleted->Add(legend);
+ //fListOfObjectsToBeDeleted->Add(legend);
TH1F *cutHistoMean = 0;
TH1F *cutHistoMedian = 0;
TH1F *cutHistoLTM = 0;
if (plotMean) {
cutHistoMean = AliTPCCalibViewer::SigmaCut(htemp, mean, sigma, sigmaMax, sigmaStep, pm);
if (cutHistoMean) {
- fListOfObjectsToBeDeleted->Add(cutHistoMean);
+ //fListOfObjectsToBeDeleted->Add(cutHistoMean);
cutHistoMean->SetLineColor(kRed);
legend->AddEntry(cutHistoMean, "Mean", "l");
cutHistoMean->SetTitle(Form("%s, cumulative; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
if (plotMedian) {
cutHistoMedian = AliTPCCalibViewer::SigmaCut(htemp, median, sigma, sigmaMax, sigmaStep, pm);
if (cutHistoMedian) {
- fListOfObjectsToBeDeleted->Add(cutHistoMedian);
+ //fListOfObjectsToBeDeleted->Add(cutHistoMedian);
cutHistoMedian->SetLineColor(kBlue);
legend->AddEntry(cutHistoMedian, "Median", "l");
cutHistoMedian->SetTitle(Form("%s, cumulative; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
Double_t ltm = GetLTM(entries, values, <mRms, ltmFraction);
cutHistoLTM = AliTPCCalibViewer::SigmaCut(htemp, ltm, ltmRms, sigmaMax, sigmaStep, pm);
if (cutHistoLTM) {
- fListOfObjectsToBeDeleted->Add(cutHistoLTM);
+ //fListOfObjectsToBeDeleted->Add(cutHistoLTM);
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 {
+ //
+ // Creates a histogram, where you can see, how much of the data are inside sigma-intervals
+ // around the mean/median/LTM
+ // with drawCommand, sector and cuts you specify your input data, see EasyDraw
+ // sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma)
+ // sigmaStep: the binsize of the generated histogram
+ // plotMean/plotMedian/plotLTM: specifies where to put the center
+ //
+
+ // Double_t ltmFraction = 0.8; //unused
+ // avoid compiler warnings:
+ sigmaMax = sigmaMax;
+ pm = pm;
+ sigmaStep = sigmaStep;
+
+ TString drawStr(drawCommand);
+ drawStr += " >> tempHist";
+
+ Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
+ TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
+ TGraph *cutGraphMean = 0;
+ // TGraph *cutGraphMedian = 0;
+ // TGraph *cutGraphLTM = 0;
+ Double_t *values = fTree->GetV1(); // value is the array containing 'entries' numbers
+ Int_t *index = new Int_t[entries];
+ Float_t *xarray = new Float_t[entries];
+ Float_t *yarray = new Float_t[entries];
+ TMath::Sort(entries, values, index, kFALSE);
+
+ Double_t mean = TMath::Mean(entries, values);
+ // Double_t median = TMath::Median(entries, values);
+ Double_t sigma = TMath::RMS(entries, values);
+
+ TLegend * legend = new TLegend(.7,.7, .99, .99, "Cumulative");
+ //fListOfObjectsToBeDeleted->Add(legend);
+
+ // parse sigmas string
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+ TVectorF nsigma(sigmasTokens->GetEntriesFast());
+ for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
+ TString str(((TObjString*)sigmasTokens->At(i))->GetString());
+ Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
+ nsigma[i] = sig;
+ }
+
+ if (plotMean) {
+ for (Int_t i = 0; i < entries; i++) {
+ xarray[i] = TMath::Abs(values[index[i]] - mean) / sigma;
+ yarray[i] = float(i) / float(entries);
+ }
+ cutGraphMean = new TGraph(entries, xarray, yarray);
+ if (cutGraphMean) {
+ //fListOfObjectsToBeDeleted->Add(cutGraphMean);
+ cutGraphMean->SetLineColor(kRed);
+ legend->AddEntry(cutGraphMean, "Mean", "l");
+ cutGraphMean->SetTitle(Form("%s, Cumulative; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
+ cutGraphMean->Draw("alu");
+ DrawLines(cutGraphMean, nsigma, legend, kRed, kTRUE);
+ }
+ }
+ /*
+ if (plotMedian) {
+ cutHistoMedian = AliTPCCalibViewer::SigmaCut(htemp, median, sigma, sigmaMax, sigmaStep, pm);
+ if (cutHistoMedian) {
+ fListOfObjectsToBeDeleted->Add(cutHistoMedian);
+ cutHistoMedian->SetLineColor(kBlue);
+ legend->AddEntry(cutHistoMedian, "Median", "l");
+ cutHistoMedian->SetTitle(Form("%s, cumulative; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
+ if (plotMean && cutHistoMean) cutHistoMedian->Draw("same");
+ else cutHistoMedian->Draw();
+ DrawLines(cutHistoMedian, nsigma, legend, kBlue, pm);
+ } // if (cutHistoMedian)
+ }
+ if (plotLTM) {
+ Double_t ltmRms = 0;
+ Double_t ltm = GetLTM(entries, values, <mRms, ltmFraction);
+ cutHistoLTM = AliTPCCalibViewer::SigmaCut(htemp, ltm, ltmRms, sigmaMax, sigmaStep, pm);
+ if (cutHistoLTM) {
+ fListOfObjectsToBeDeleted->Add(cutHistoLTM);
+ 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");
+ else cutHistoLTM->Draw();
+ DrawLines(cutHistoLTM, nsigma, legend, kGreen+2, pm);
+ }
+ }*/
+ if (!plotMean && !plotMedian && !plotLTM) return -1;
+ legend->Draw();
+ return 1;
+}
Int_t AliTPCCalibViewer::Integrate(const char* drawCommand, Int_t 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 {
+Int_t AliTPCCalibViewer::IntegrateOld(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
}
TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
- fListOfObjectsToBeDeleted->Add(legend);
+ //fListOfObjectsToBeDeleted->Add(legend);
TH1F *integralHistoMean = 0;
TH1F *integralHistoMedian = 0;
TH1F *integralHistoLTM = 0;
if (plotMean) {
integralHistoMean = AliTPCCalibViewer::Integrate(htemp, mean, sigma, sigmaMax, sigmaStep);
if (integralHistoMean) {
- fListOfObjectsToBeDeleted->Add(integralHistoMean);
+ //fListOfObjectsToBeDeleted->Add(integralHistoMean);
integralHistoMean->SetLineColor(kRed);
legend->AddEntry(integralHistoMean, "Mean", "l");
integralHistoMean->SetTitle(Form("%s, integrated; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
if (plotMedian) {
integralHistoMedian = AliTPCCalibViewer::Integrate(htemp, median, sigma, sigmaMax, sigmaStep);
if (integralHistoMedian) {
- fListOfObjectsToBeDeleted->Add(integralHistoMedian);
+ //fListOfObjectsToBeDeleted->Add(integralHistoMedian);
integralHistoMedian->SetLineColor(kBlue);
legend->AddEntry(integralHistoMedian, "Median", "l");
integralHistoMedian->SetTitle(Form("%s, integrated; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
Double_t ltm = GetLTM(entries, values, <mRms, ltmFraction);
integralHistoLTM = AliTPCCalibViewer::Integrate(htemp, ltm, ltmRms, sigmaMax, sigmaStep);
if (integralHistoLTM) {
- fListOfObjectsToBeDeleted->Add(integralHistoLTM);
+ //fListOfObjectsToBeDeleted->Add(integralHistoLTM);
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 {
+ //
+ // 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
+ // if "igma == 0" and "sigmaMax == 0" the whole histogram is integrated
+ // "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 }
+ End_Latex
+ */
+
+ Double_t ltmFraction = 0.8;
+ // avoid compiler warnings:
+ sigmaMax = sigmaMax;
+ sigmaStep = sigmaStep;
+
+ TString drawStr(drawCommand);
+ Bool_t dangerousToDraw = drawStr.Contains(":") || drawStr.Contains(">>");
+ if (dangerousToDraw) {
+ Warning("Integrate", "The draw string must not contain ':' or '>>'.");
+ return -1;
+ }
+ drawStr += " >> tempHist";
+
+ Int_t entries = EasyDraw1D(drawStr.Data(), sector, cuts, "goff");
+ TH1F *htemp = (TH1F*)gDirectory->Get("tempHist");
+ TGraph *integralGraphMean = 0;
+ TGraph *integralGraphMedian = 0;
+ TGraph *integralGraphLTM = 0;
+ Double_t *values = fTree->GetV1(); // value is the array containing 'entries' numbers
+ Int_t *index = new Int_t[entries];
+ Float_t *xarray = new Float_t[entries];
+ Float_t *yarray = new Float_t[entries];
+ TMath::Sort(entries, values, index, kFALSE);
+
+ Double_t mean = TMath::Mean(entries, values);
+ Double_t median = TMath::Median(entries, values);
+ Double_t sigma = TMath::RMS(entries, values);
+
+ // parse sigmas string
+ TObjArray *sigmasTokens = TString(sigmas).Tokenize(";");
+ TVectorF nsigma(sigmasTokens->GetEntriesFast());
+ for (Int_t i = 0; i < sigmasTokens->GetEntriesFast(); i++) {
+ TString str(((TObjString*)sigmasTokens->At(i))->GetString());
+ Double_t sig = (str.IsFloat()) ? str.Atof() : 0;
+ nsigma[i] = sig;
+ }
+
+ TLegend * legend = new TLegend(.7,.7, .99, .99, "Integrated histogram");
+ //fListOfObjectsToBeDeleted->Add(legend);
+
+ if (plotMean) {
+ for (Int_t i = 0; i < entries; i++) {
+ xarray[i] = (values[index[i]] - mean) / sigma;
+ yarray[i] = float(i) / float(entries);
+ }
+ integralGraphMean = new TGraph(entries, xarray, yarray);
+ if (integralGraphMean) {
+ //fListOfObjectsToBeDeleted->Add(integralGraphMean);
+ integralGraphMean->SetLineColor(kRed);
+ legend->AddEntry(integralGraphMean, "Mean", "l");
+ integralGraphMean->SetTitle(Form("%s, integrated; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
+ integralGraphMean->Draw("alu");
+ DrawLines(integralGraphMean, nsigma, legend, kRed, kTRUE);
+ }
+ }
+ if (plotMedian) {
+ for (Int_t i = 0; i < entries; i++) {
+ xarray[i] = (values[index[i]] - median) / sigma;
+ yarray[i] = float(i) / float(entries);
+ }
+ integralGraphMedian = new TGraph(entries, xarray, yarray);
+ if (integralGraphMedian) {
+ //fListOfObjectsToBeDeleted->Add(integralGraphMedian);
+ integralGraphMedian->SetLineColor(kBlue);
+ legend->AddEntry(integralGraphMedian, "Median", "l");
+ integralGraphMedian->SetTitle(Form("%s, integrated; Multiples of #sigma; Fraction of included data", htemp->GetTitle()));
+ if (plotMean && integralGraphMean) integralGraphMedian->Draw("samelu");
+ else integralGraphMedian->Draw("alu");
+ DrawLines(integralGraphMedian, nsigma, legend, kBlue, kTRUE);
+ }
+ }
+ if (plotLTM) {
+ Double_t ltmRms = 0;
+ Double_t ltm = GetLTM(entries, values, <mRms, ltmFraction);
+ for (Int_t i = 0; i < entries; i++) {
+ xarray[i] = (values[index[i]] - ltm) / ltmRms;
+ yarray[i] = float(i) / float(entries);
+ }
+ integralGraphLTM = new TGraph(entries, xarray, yarray);
+ if (integralGraphLTM) {
+ //fListOfObjectsToBeDeleted->Add(integralGraphLTM);
+ 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");
+ else integralGraphLTM->Draw("alu");
+ DrawLines(integralGraphLTM, nsigma, legend, kGreen+2, kTRUE);
+ }
+ }
+ if (!plotMean && !plotMedian && !plotLTM) return -1;
+ legend->Draw();
+ return entries;
+}
+
+
void AliTPCCalibViewer::DrawLines(TH1F *histogram, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const {
//
// Private function for SigmaCut(...) and Integrate(...)
if (!pm) {
Int_t bin = histogram->GetXaxis()->FindBin(nsigma[i]);
TLine* lineUp = new TLine(nsigma[i], 0, nsigma[i], histogram->GetBinContent(bin));
- fListOfObjectsToBeDeleted->Add(lineUp);
+ //fListOfObjectsToBeDeleted->Add(lineUp);
lineUp->SetLineColor(color);
lineUp->SetLineStyle(2 + i);
lineUp->Draw();
TLine* lineLeft = new TLine(nsigma[i], histogram->GetBinContent(bin), 0, histogram->GetBinContent(bin));
- fListOfObjectsToBeDeleted->Add(lineLeft);
+ //fListOfObjectsToBeDeleted->Add(lineLeft);
lineLeft->SetLineColor(color);
lineLeft->SetLineStyle(2 + i);
lineLeft->Draw();
else { // if (pm)
Int_t bin = histogram->GetXaxis()->FindBin(nsigma[i]);
TLine* lineUp1 = new TLine(nsigma[i], 0, nsigma[i], histogram->GetBinContent(bin));
- fListOfObjectsToBeDeleted->Add(lineUp1);
+ //fListOfObjectsToBeDeleted->Add(lineUp1);
lineUp1->SetLineColor(color);
lineUp1->SetLineStyle(2 + i);
lineUp1->Draw();
TLine* lineLeft1 = new TLine(nsigma[i], histogram->GetBinContent(bin), histogram->GetBinLowEdge(0)+histogram->GetBinWidth(0), histogram->GetBinContent(bin));
- fListOfObjectsToBeDeleted->Add(lineLeft1);
+ //fListOfObjectsToBeDeleted->Add(lineLeft1);
lineLeft1->SetLineColor(color);
lineLeft1->SetLineStyle(2 + i);
lineLeft1->Draw();
legend->AddEntry(lineLeft1, c, "l");
bin = histogram->GetXaxis()->FindBin(-nsigma[i]);
TLine* lineUp2 = new TLine(-nsigma[i], 0, -nsigma[i], histogram->GetBinContent(bin));
- fListOfObjectsToBeDeleted->Add(lineUp2);
+ //fListOfObjectsToBeDeleted->Add(lineUp2);
lineUp2->SetLineColor(color);
lineUp2->SetLineStyle(2 + i);
lineUp2->Draw();
TLine* lineLeft2 = new TLine(-nsigma[i], histogram->GetBinContent(bin), histogram->GetBinLowEdge(0)+histogram->GetBinWidth(0), histogram->GetBinContent(bin));
- fListOfObjectsToBeDeleted->Add(lineLeft2);
+ //fListOfObjectsToBeDeleted->Add(lineLeft2);
lineLeft2->SetLineColor(color);
lineLeft2->SetLineStyle(2 + i);
lineLeft2->Draw();
}
+void AliTPCCalibViewer::DrawLines(TGraph *graph, TVectorF nsigma, TLegend *legend, Int_t color, Bool_t pm) const {
+ //
+ // Private function for SigmaCut(...) and Integrate(...)
+ // Draws lines into the given histogram, specified by "nsigma", the lines are addeed to the legend
+ //
+
+ // 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]));
+ //fListOfObjectsToBeDeleted->Add(lineUp);
+ lineUp->SetLineColor(color);
+ lineUp->SetLineStyle(2 + i);
+ lineUp->Draw();
+ TLine* lineLeft = new TLine(nsigma[i], graph->Eval(nsigma[i]), 0, graph->Eval(nsigma[i]));
+ //fListOfObjectsToBeDeleted->Add(lineLeft);
+ 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");
+ }
+ else { // if (pm)
+ TLine* lineUp1 = new TLine(nsigma[i], 0, nsigma[i], graph->Eval(nsigma[i]));
+ //fListOfObjectsToBeDeleted->Add(lineUp1);
+ lineUp1->SetLineColor(color);
+ lineUp1->SetLineStyle(2 + i);
+ lineUp1->Draw();
+ TLine* lineLeft1 = new TLine(nsigma[i], graph->Eval(nsigma[i]), graph->GetHistogram()->GetXaxis()->GetBinLowEdge(0), graph->Eval(nsigma[i]));
+ //fListOfObjectsToBeDeleted->Add(lineLeft1);
+ 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");
+ TLine* lineUp2 = new TLine(-nsigma[i], 0, -nsigma[i], graph->Eval(-nsigma[i]));
+ //fListOfObjectsToBeDeleted->Add(lineUp2);
+ lineUp2->SetLineColor(color);
+ lineUp2->SetLineStyle(2 + i);
+ lineUp2->Draw();
+ TLine* lineLeft2 = new TLine(-nsigma[i], graph->Eval(-nsigma[i]), graph->GetHistogram()->GetXaxis()->GetBinLowEdge(0), graph->Eval(-nsigma[i]));
+ //fListOfObjectsToBeDeleted->Add(lineLeft2);
+ 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");
+ }
+ } // for (Int_t i = 0; i < nsigma.GetNoElements(); i++)
+}
+
Float_t sigma = 1.5;
Float_t sigmaMax = 4;
gROOT->SetStyle("Plain");
- TH1F *distribution = new TH1F("Distribution", "Distribution f(x, #mu, #sigma)", 1000,-5,5);
+ TH1F *distribution = new TH1F("Distribution1", "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", "", 350, 350);
+ TCanvas* macro_example_canvas = new TCanvas("macro_example_canvas_SigmaCut", "", 350, 350);
macro_example_canvas->Divide(0,3);
TVirtualPad *pad1 = macro_example_canvas->cd(1);
pad1->SetGridy();
}
-
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){
//
// 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
Float_t sigma = 1.5;
Float_t sigmaMax = 4;
gROOT->SetStyle("Plain");
- TH1F *distribution = new TH1F("Distribution", "Distribution f(x, #mu, #sigma)", 1000,-5,5);
+ TH1F *distribution = new TH1F("Distribution2", "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", "", 350, 350);
+ TCanvas* macro_example_canvas = new TCanvas("macro_example_canvas_Integrate", "", 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;
+ return macro_example_canvas_Integrate;
}
end_macro
*/
//_____________________________________________________________________________
-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
// - this takes a while -
//
TString drawStr(desiredData);
- drawStr.Append(":channel~");
+ drawStr.Append(":channel");
+ drawStr.Append(fAbbreviation);
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;
}
+
//_____________________________________________________________________________
-AliTPCCalROC* AliTPCCalibViewer::GetCalROC(const char* desiredData, UInt_t sector, char* cuts) const {
+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, 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(":channel~");
+ 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());
str->String() == "row" || str->String() == "rpad" || str->String() == "sector" ))
arr->Add(str);
}
+
+ // loop over all friends (if there are some) and add them to the list
+ if (fTree->GetListOfFriends()) {
+ for (Int_t ifriend = 0; ifriend < fTree->GetListOfFriends()->GetEntries(); ifriend++){
+ // printf("iterating through friendlist, currently at %i\n", ifriend);
+ // printf("working with %s\n", fTree->GetListOfFriends()->At(ifriend)->ClassName());
+ if (TString(fTree->GetListOfFriends()->At(ifriend)->ClassName()) != "TFriendElement") continue; // no friendElement found
+ TFriendElement *friendElement = (TFriendElement*)fTree->GetListOfFriends()->At(ifriend);
+ if (friendElement->GetTree() == 0) continue; // no tree found in friendElement
+ // printf("friend found \n");
+ for (Int_t i = 0; i < friendElement->GetTree()->GetListOfBranches()->GetEntries(); i++) {
+ // printf("iterating through friendelement entries, currently at %i\n", i);
+ str = new TObjString(friendElement->GetTree()->GetListOfBranches()->At(i)->GetName());
+ str->String().ReplaceAll("_Median", "");
+ str->String().ReplaceAll("_Mean", "");
+ str->String().ReplaceAll("_RMS", "");
+ str->String().ReplaceAll("_LTM", "");
+ str->String().ReplaceAll("_OutlierCutted", "");
+ str->String().ReplaceAll(".", "");
+ if (!(str->String() == "channel" || str->String() == "gx" || str->String() == "gy" ||
+ str->String() == "lx" || str->String() == "ly" || str->String() == "pad" ||
+ str->String() == "row" || str->String() == "rpad" || str->String() == "sector" )){
+ // insert "<friendName>." at the beginning: (<friendName> is per default "R")
+ str->String().Insert(0, ".");
+ str->String().Insert(0, friendElement->GetName());
+ if (!arr->FindObject(str)) arr->Add(str);
+ // printf("added string %s \n", str->String().Data());
+ }
+ }
+ }
+ } // if (fTree->GetListOfFriends())
+
arr->Sort();
+// ((TFriendElement*)gui->GetViewer()->GetTree()->GetListOfFriends()->At(0))->GetTree()->GetListOfBranches()->At(0)->GetName()
+// ((TFriendElement*)gui->GetViewer()->GetTree()->GetListOfFriends()->At(0))->GetTree()->GetListOfBranches()
+
if (printList) {
TIterator* iter = arr->MakeIterator();
arr->Add(new TObjString("_Median_OutlierCutted"));
arr->Add(new TObjString("_LTM"));
arr->Add(new TObjString("_LTM_OutlierCutted"));
- arr->Add(new TObjString("LFitIntern_4_8.fElements"));
- arr->Add(new TObjString("GFitIntern_Lin.fElements"));
- arr->Add(new TObjString("GFitIntern_Par.fElements"));
+ arr->Add(new TObjString(Form("LFitIntern_4_8%s", fAppendString.Data())));
+ arr->Add(new TObjString(Form("GFitIntern_Lin%s", fAppendString.Data())));
+ arr->Add(new TObjString(Form("GFitIntern_Par%s", fAppendString.Data())));
arr->Add(new TObjString("FitLinLocal"));
arr->Add(new TObjString("FitLinGlobal"));
arr->Add(new TObjString("FitParLocal"));
TObjArray *calPadsArray = new TObjArray();
Int_t numberOfCalPads = listOfCalPads->GetEntries();
for (Int_t i = 0; i < numberOfCalPads; i++) {
- std::cout << "Creating calPad " << (i+1) << " of " << numberOfCalPads << "\r" << std::flush;
+ std::cout << "Creating calPad " << (i+1) << " of " << numberOfCalPads << "\r" << std::flush;
char* calPadName = (char*)((TObjString*)(listOfCalPads->At(i)))->GetString().Data();
TString drawCommand = ((TObjString*)(listOfCalPads->At(i)))->GetString();
- drawCommand.Append("~");
+ drawCommand.Append(fAbbreviation.Data());
AliTPCCalPad* calPad = GetCalPad(drawCommand.Data(), "", calPadName);
calPadsArray->Add(calPad);
}
TString cutStr(cuts);
// abbreviations:
- drawStr.ReplaceAll("~",".fElements");
- cutStr.ReplaceAll("~",".fElements");
- formulaStr.ReplaceAll("~", ".fElements");
+ drawStr.ReplaceAll(fAbbreviation, fAppendString);
+ cutStr.ReplaceAll(fAbbreviation, fAppendString);
+ formulaStr.ReplaceAll(fAbbreviation, fAppendString);
- formulaStr.ReplaceAll("++", "~");
- TObjArray* formulaTokens = formulaStr.Tokenize("~");
+ formulaStr.ReplaceAll("++", fAbbreviation);
+ TObjArray* formulaTokens = formulaStr.Tokenize(fAbbreviation.Data());
Int_t dim = formulaTokens->GetEntriesFast();
fitParam.ResizeTo(dim);
}
}
+
+void AliTPCCalibViewer::MakeTree(const char *outPutFileName, const Char_t *inputFileName, AliTPCCalPad *outlierPad, Float_t ltmFraction, const char *mapFileName ){
+ //
+ // Function to create a calibration Tree with all available information.
+ // See also documentation to MakeTree
+ // the file "inputFileName" must be in the following format (see also CreateObjectList):
+ // (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
+ //
+ // type path dependingOnType
+ //
+ // type == "CE":
+ // dependingOnType = CETmean CEQmean CETrms
+ //
+ // type == "Pulser":
+ // dependingOnType = PulserTmean PulsterQmean PulserTrms
+ //
+ // type == "Pedestals":
+ // dependingOnType = Pedestals Noise
+ //
+ // type == "CalPad":
+ // dependingOnType = NameInFile NameToWriteToFile
+ //
+ //
+ TObjArray objArray;
+ CreateObjectList(inputFileName, &objArray);
+ MakeTree(outPutFileName, &objArray, mapFileName, outlierPad, ltmFraction);
+}
+
+
+void AliTPCCalibViewer::CreateObjectList(const Char_t *filename, TObjArray *calibObjects){
+ //
+ // Function to create a TObjArray out of a given file
+ // the file must be in the following format:
+ // (each colum separated by tabs, "dependingOnType" can have 2 or 3 colums)
+ //
+ //
+ // type path dependingOnType
+ //
+ // type == "CE":
+ // dependingOnType = CETmean CEQmean CETrms
+ //
+ // type == "Pulser":
+ // dependingOnType = PulserTmean PulsterQmean PulserTrms
+ //
+ // type == "Pedestals":
+ // dependingOnType = Pedestals Noise
+ //
+ // type == "CalPad":
+ // dependingOnType = NameInFile NameToWriteToFile
+ //
+ //
+ //
+ if ( calibObjects == 0x0 ) return;
+ ifstream in;
+ in.open(filename);
+ if ( !in.is_open() ){
+ fprintf(stderr,"Error: cannot open list file '%s'", filename);
+ return;
+ }
+
+ AliTPCCalPad *calPad=0x0;
+
+ TString sFile;
+ sFile.ReadFile(in);
+ in.close();
+
+ TObjArray *arrFileLine = sFile.Tokenize("\n");
+ TIter nextLine(arrFileLine);
+
+ TObjString *sObjLine = 0x0;
+ while ( (sObjLine = (TObjString*)nextLine()) ){
+ TString sLine(sObjLine->GetString());
+
+ TObjArray *arrCol = sLine.Tokenize("\t");
+ Int_t nCols = arrCol->GetEntriesFast();
+
+ TObjString *sObjType = (TObjString*)(arrCol->At(0));
+ TObjString *sObjFileName = (TObjString*)(arrCol->At(1));
+ TObjString *sObjName = 0x0;
+
+ if ( !sObjType || !sObjFileName ) continue;
+ TString sType(sObjType->GetString());
+ TString sFileName(sObjFileName->GetString());
+ printf("Type %s, opening %s \n", sType.Data(), sFileName.Data());
+ TFile *fIn = TFile::Open(sFileName);
+ if ( !fIn ){
+ fprintf(stderr,"File not found: '%s'", sFileName.Data());
+ continue;
+ }
+
+ if ( sType == "CE" ){ // next three colums are the names for CETmean, CEQmean and CETrms
+ AliTPCCalibCE *ce = (AliTPCCalibCE*)fIn->Get("AliTPCCalibCE");
+ calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadT0());
+ if (nCols > 2) { // check, if the name is provided
+ sObjName = (TObjString*)(arrCol->At(2));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("CETmean","CETmean");
+ calibObjects->Add(calPad);
+
+ calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadQ());
+ if (nCols > 3) { // check, if the name is provided
+ sObjName = (TObjString*)(arrCol->At(3));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("CEQmean","CEQmean");
+ calibObjects->Add(calPad);
+
+ calPad = new AliTPCCalPad((TObjArray*)ce->GetCalPadRMS());
+ if (nCols > 4) { // check, if the name is provided
+ sObjName = (TObjString*)(arrCol->At(4));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("CETrms","CETrms");
+ calibObjects->Add(calPad);
+
+ } else if ( sType == "Pulser") {
+ AliTPCCalibPulser *sig = (AliTPCCalibPulser*)fIn->Get("AliTPCCalibPulser");
+
+ calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadT0());
+ if (nCols > 2) {
+ sObjName = (TObjString*)(arrCol->At(2));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("PulserTmean","PulserTmean");
+ calibObjects->Add(calPad);
+
+ calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadQ());
+ if (nCols > 3) {
+ sObjName = (TObjString*)(arrCol->At(3));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("PulserQmean","PulserQmean");
+ calibObjects->Add(calPad);
+
+ calPad = new AliTPCCalPad((TObjArray*)sig->GetCalPadRMS());
+ if (nCols > 4) {
+ sObjName = (TObjString*)(arrCol->At(4));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("PulserTrms","PulserTrms");
+ calibObjects->Add(calPad);
+
+ } else if ( sType == "Pedestals") {
+ AliTPCCalibPedestal *ped = (AliTPCCalibPedestal*)fIn->Get("AliTPCCalibPedestal");
+
+ calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadPedestal());
+ if (nCols > 2) {
+ sObjName = (TObjString*)(arrCol->At(2));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("Pedestals","Pedestals");
+ calibObjects->Add(calPad);
+
+ calPad = new AliTPCCalPad((TObjArray*)ped->GetCalPadRMS());
+ if (nCols > 3) {
+ sObjName = (TObjString*)(arrCol->At(3));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ else calPad->SetNameTitle("Noise","Noise");
+ calibObjects->Add(calPad);
+
+ } else if ( sType == "CalPad") {
+ if (nCols > 2) sObjName = (TObjString*)(arrCol->At(2));
+ else continue;
+ calPad = new AliTPCCalPad(*(AliTPCCalPad*)fIn->Get(sObjName->GetString().Data()));
+ if (nCols > 3) {
+ sObjName = (TObjString*)(arrCol->At(3));
+ calPad->SetNameTitle(sObjName->GetString().Data(), sObjName->GetString().Data());
+ }
+ calibObjects->Add(calPad);
+ } else {
+ fprintf(stderr,"Undefined Type: '%s'",sType.Data());
+ }
+ delete fIn;
+ }
+}
+
+
+