ROOT logo
AliRoot » STEER » CDB » AliBaseCalibViewer

class AliBaseCalibViewer: public TObject


Base class for the AliTPCCalibViewer and AliTRDCalibViewer
used for the calibration monitor

Authors:     Marian Ivanov (Marian.Ivanov@cern.ch)
Jens Wiechula (Jens.Wiechula@cern.ch)
Ionut Arsene  (iarsene@cern.ch)


Function Members (Methods)

 
    This is an abstract class, constructors will not be documented.
    Look at the header to check for available constructors.

public:
virtual~AliBaseCalibViewer()
voidTObject::AbstractMethod(const char* method) const
virtual const char*AddAbbreviations(Char_t* c, Bool_t printDrawCommand = kFALSE)
TFriendElement*AddFriend(const Char_t* treename, const Char_t* filename)
TFriendElement*AddFriend(const Char_t* treename, TFile* file)
TFriendElement*AddFriend(TTree* tree, const Char_t* alias, Bool_t warn = kFALSE)
TFriendElement*AddReferenceTree(const Char_t* filename, const Char_t* treename = "tree", const Char_t* refname = "R")
virtual voidTObject::AppendPad(Option_t* option = "")
virtual voidTObject::Browse(TBrowser* b)
static TClass*Class()
virtual const char*TObject::ClassName() const
virtual voidTObject::Clear(Option_t* = "")
virtual TObject*TObject::Clone(const char* newname = "") const
virtual Int_tTObject::Compare(const TObject* obj) const
virtual voidTObject::Copy(TObject& object) const
virtual voidDelete(Option_t* option = "")
virtual Int_tTObject::DistancetoPrimitive(Int_t px, Int_t py)
virtual voidDraw(Option_t* opt = "")
virtual Long64_tDraw(const Char_t* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual Long64_tDraw(const Char_t* varexp, const Char_t* selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
virtual voidTObject::DrawClass() constMENU
virtual TObject*TObject::DrawClone(Option_t* option = "") constMENU
Int_tDrawHisto1D(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, const Char_t* sigmas = "2;4;6", Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE) const
virtual voidTObject::Dump() constMENU
virtual Int_tEasyDraw(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, const Char_t* drawOptions = 0, Bool_t writeDrawCommand = kFALSE) const
virtual Int_tEasyDraw(const Char_t* drawCommand, Int_t sector, const Char_t* cuts = 0, const Char_t* drawOptions = 0, Bool_t writeDrawCommand = kFALSE) const
virtual Int_tEasyDraw1D(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, const Char_t* drawOptions = 0, Bool_t writeDrawCommand = kFALSE) const
virtual Int_tEasyDraw1D(const Char_t* drawCommand, Int_t sector, const Char_t* cuts = 0, const Char_t* drawOptions = 0, Bool_t writeDrawCommand = kFALSE) const
virtual voidTObject::Error(const char* method, const char* msgfmt) const
virtual voidTObject::Execute(const char* method, const char* params, Int_t* error = 0)
virtual voidTObject::Execute(TMethod* method, TObjArray* params, Int_t* error = 0)
virtual voidTObject::ExecuteEvent(Int_t event, Int_t px, Int_t py)
virtual voidTObject::Fatal(const char* method, const char* msgfmt) const
virtual TObject*TObject::FindObject(const char* name) const
virtual TObject*TObject::FindObject(const TObject* obj) const
TString*Fit(const Char_t* drawCommand, const Char_t* formula, const Char_t* cuts, Double_t& chi2, TVectorD& fitParam, TMatrixD& covMatrix)
voidFormatHistoLabels(TH1* histo) const
TString&GetAbbreviation()
TString&GetAppendString()
static Int_tGetBin(Float_t value, Int_t nbins, Double_t binLow, Double_t binUp)
virtual Option_t*TObject::GetDrawOption() const
static Long_tTObject::GetDtorOnly()
virtual const char*TObject::GetIconName() const
virtual TObjArray*GetListOfNormalizationVariables(Bool_t printList = kFALSE) const
virtual TObjArray*GetListOfVariables(Bool_t printList = kFALSE)
static Double_tGetLTM(Int_t n, Double_t* array, Double_t* sigma = 0, Double_t fraction = 0.9)
virtual const char*TObject::GetName() const
virtual char*TObject::GetObjectInfo(Int_t px, Int_t py) const
static Bool_tTObject::GetObjectStat()
virtual Option_t*TObject::GetOption() const
virtual const char*TObject::GetTitle() const
TTree*GetTree() const
virtual UInt_tTObject::GetUniqueID() const
virtual Bool_tTObject::HandleTimer(TTimer* timer)
virtual ULong_tTObject::Hash() const
virtual voidTObject::Info(const char* method, const char* msgfmt) const
virtual Bool_tTObject::InheritsFrom(const char* classname) const
virtual Bool_tTObject::InheritsFrom(const TClass* cl) const
virtual voidTObject::Inspect() constMENU
static TH1F*Integrate(TH1F* histogram, Float_t mean = 0, Float_t sigma = 0, Float_t sigmaMax = 0, Float_t sigmaStep = -1)
Int_tIntegrate(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, Float_t sigmaMax = 5, Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE, const Char_t* sigmas = "", Float_t sigmaStep = -1) const
static TH1F*Integrate(Int_t n, Float_t* array, Int_t nbins, Float_t binLow, Float_t binUp, Float_t mean = 0, Float_t sigma = 0, Float_t sigmaMax = 0, Float_t sigmaStep = -1)
voidTObject::InvertBit(UInt_t f)
virtual TClass*IsA() const
virtual Bool_tTObject::IsEqual(const TObject* obj) const
virtual Bool_tTObject::IsFolder() const
Bool_tTObject::IsOnHeap() const
virtual Bool_tTObject::IsSortable() const
Bool_tTObject::IsZombie() const
virtual voidTObject::ls(Option_t* option = "") const
voidTObject::MayNotUse(const char* method) const
virtual Bool_tTObject::Notify()
voidTObject::Obsolete(const char* method, const char* asOfVers, const char* removedFromVers) const
static voidTObject::operator delete(void* ptr)
static voidTObject::operator delete(void* ptr, void* vp)
static voidTObject::operator delete[](void* ptr)
static voidTObject::operator delete[](void* ptr, void* vp)
void*TObject::operator new(size_t sz)
void*TObject::operator new(size_t sz, void* vp)
void*TObject::operator new[](size_t sz)
void*TObject::operator new[](size_t sz, void* vp)
AliBaseCalibViewer&operator=(const AliBaseCalibViewer& param)
virtual voidTObject::Paint(Option_t* option = "")
virtual voidTObject::Pop()
virtual voidTObject::Print(Option_t* option = "") const
virtual Int_tTObject::Read(const char* name)
virtual voidTObject::RecursiveRemove(TObject* obj)
voidTObject::ResetBit(UInt_t f)
virtual voidTObject::SaveAs(const char* filename = "", Option_t* option = "") constMENU
virtual voidTObject::SavePrimitive(basic_ostream<char,char_traits<char> >& out, Option_t* option = "")
voidSetAbbreviation(const Char_t* abr)
voidSetAppendString(const Char_t* str)
voidTObject::SetBit(UInt_t f)
voidTObject::SetBit(UInt_t f, Bool_t set)
virtual voidTObject::SetDrawOption(Option_t* option = "")MENU
static voidTObject::SetDtorOnly(void* obj)
static voidTObject::SetObjectStat(Bool_t stat)
virtual voidTObject::SetUniqueID(UInt_t uid)
virtual voidShowMembers(TMemberInspector&)
static TH1F*SigmaCut(TH1F* histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep = -1, Bool_t pm = kFALSE)
static TH1F*SigmaCut(Int_t n, Double_t* array, Double_t mean, Double_t sigma, Int_t nbins, Double_t* xbins, Double_t sigmaMax)
Int_tSigmaCut(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, Float_t sigmaMax = 5, Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE, Bool_t pm = kFALSE, const Char_t* sigmas = "", Float_t sigmaStep = -1) const
static TH1F*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 = -1, Bool_t pm = kFALSE)
virtual voidStreamer(TBuffer&)
voidStreamerNVirtual(TBuffer& ClassDef_StreamerNVirtual_b)
virtual voidTObject::SysError(const char* method, const char* msgfmt) const
Bool_tTObject::TestBit(UInt_t f) const
Int_tTObject::TestBits(UInt_t f) const
virtual voidTObject::UseCurrentStyle()
virtual voidTObject::Warning(const char* method, const char* msgfmt) const
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0)
virtual Int_tTObject::Write(const char* name = 0, Int_t option = 0, Int_t bufsize = 0) const
protected:
virtual voidTObject::DoError(int level, const char* location, const char* fmt, va_list va) const
voidDrawLines(TH1F* cutHistoMean, TVectorF nsigma, TLegend* legend, Int_t color, Bool_t pm) const
voidDrawLines(TGraph* graph, TVectorF nsigma, TLegend* legend, Int_t color, Bool_t pm) const
voidTObject::MakeZombie()

Data Members

protected:
TStringfAbbreviationthe abreviation for '.fElements'
TStringfAppendString'.fElements', stored in a TStrig
TFile*fFilefile that contains a calPads tree (e.g. written by AliTPCCalPad::MakeTree(...)
TObjArray*fListOfObjectsToBeDeletedObjects, that will be deleted when the destructor ist called
TTree*fTreetree containing visualization data (e.g. written by AliTPCCalPad::MakeTree(...)
Bool_tfTreeMustBeDeleteddecides weather the tree must be deleted in destructor or not

Class Charts

Inheritance Chart:
TObject
AliBaseCalibViewer
AliTRDCalibViewer

Function documentation

~AliBaseCalibViewer()
 AliBaseCalibViewer destructor
 all objects will be deleted, the file will be closed, the pictures will disappear

void Delete(Option_t* option = "")
 Should be called from AliBaseCalibViewerGUI 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.

void FormatHistoLabels(TH1* histo) const
 formats title and axis labels of histo
 removes '.fElements'

TFriendElement* AddReferenceTree(const Char_t* filename, const Char_t* treename = "tree", const Char_t* refname = "R")
 add a reference tree to the current tree
 by default the treename is 'tree' and the reference treename is 'R'

TString* Fit(const Char_t* drawCommand, const Char_t* formula, const Char_t* cuts, Double_t& chi2, TVectorD& fitParam, TMatrixD& covMatrix)
 fit an arbitrary function, specified by formula into the data, specified by drawCommand and cuts
 returns chi2, fitParam and covMatrix
 returns TString with fitted formula

Double_t GetLTM(Int_t n, Double_t* array, Double_t* sigma = 0, Double_t fraction = 0.9)
  returns the LTM and sigma

Int_t GetBin(Float_t value, Int_t nbins, Double_t binLow, Double_t binUp)
 Returns the 'bin' for 'value'
 The interval between 'binLow' and 'binUp' is divided into 'nbins' equidistant bins
 avoid index out of bounds error: 'if (bin < binLow) bin = binLow' and vice versa

GetBin(value) = #frac{nbins - 1}{binUp - binLow} #upoint (value - binLow) +1

TH1F* SigmaCut(TH1F* histogram, Float_t mean, Float_t sigma, Float_t sigmaMax, Float_t sigmaStep = -1, Bool_t pm = kFALSE)
 Creates a cumulative histogram S(t, #mu, #sigma), where you can see, how much of the data are inside sigma-intervals around the mean value
 The data of the distribution f(x, #mu, #sigma) are given in 'histogram'
 'mean' and 'sigma' are #mu and  #sigma of the distribution in 'histogram', to be specified by the user
 sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, t #sigma)
 sigmaStep: the binsize of the generated histogram, -1 means, that the maximal reasonable stepsize is used
 pm: Decide weather t > 0 (first case) or t arbitrary (secound case)
 The actual work is done on the array.

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

output of MACRO_AliBaseCalibViewer_SigmaCut_4_8_cAliBaseCalibViewer
     {
     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);
     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("cAliBaseCalibViewer", "", 350, 350);
     macro_example_canvas->Divide(0,3);
     TVirtualPad *pad1 = macro_example_canvas->cd(1);
     pad1->SetGridy();
     pad1->SetGridx();
     distribution->Draw();
     TVirtualPad *pad2 = macro_example_canvas->cd(2);
     pad2->SetGridy();
     pad2->SetGridx();

     TH1F *shist = AliTPCCalibViewer::SigmaCut(distribution, mean, sigma, sigmaMax);
     shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
     shist->Draw();  
     TVirtualPad *pad3 = macro_example_canvas->cd(3);
     pad3->SetGridy();
     pad3->SetGridx();
     TH1F *shistPM = AliTPCCalibViewer::SigmaCut(distribution, mean, sigma, sigmaMax, -1, kTRUE);
     shistPM->Draw();   
     return macro_example_canvas;
     }  
     

TH1F* 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 = -1, Bool_t pm = kFALSE)
 Creates a histogram S(t, #mu, #sigma), where you can see, how much of the data are inside sigma-intervals around the mean value
 The data of the distribution f(x, #mu, #sigma) are given in 'array', 'n' specifies the length of the array
 'mean' and 'sigma' are #mu and  #sigma of the distribution in 'array', to be specified by the user
 'nbins': number of bins, 'binLow': first bin, 'binUp': last bin
 sigmaMax: up to which sigma around the mean/median/LTM the histogram is generated (in units of sigma, t #sigma)
 sigmaStep: the binsize of the generated histogram
 Here the actual work is done.
TH1F* SigmaCut(Int_t n, Double_t* array, Double_t mean, Double_t sigma, Int_t nbins, Double_t* xbins, Double_t sigmaMax)
 SigmaCut for variable binsize
 NOT YET IMPLEMENTED !!!

Int_t DrawHisto1D(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, const Char_t* sigmas = "2;4;6", Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE) const
 Easy drawing of data, in principle the same as EasyDraw1D
 Difference: A line for the mean / median / LTM is drawn
 in 'sigmas' you can specify in which distance to the mean/median/LTM you want to see a line in sigma-units, separated by ';'
 example: sigmas = "2; 4; 6;"  at 2 #sigma, 4 #sigma and 6 #sigma  a line is drawn.
 "plotMean", "plotMedian" and "plotLTM": what kind of lines do you want to see?

Int_t SigmaCut(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, Float_t sigmaMax = 5, Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE, Bool_t pm = kFALSE, const Char_t* sigmas = "", Float_t sigmaStep = -1) 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

Int_t Integrate(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, Float_t sigmaMax = 5, Bool_t plotMean = kTRUE, Bool_t plotMedian = kTRUE, Bool_t plotLTM = kTRUE, const Char_t* sigmas = "", Float_t sigmaStep = -1) const
 Creates an integrated histogram S(t, #mu, #sigma), out of the input distribution distribution f(x, #mu, #sigma), given in "histogram"
 "mean" and "sigma" are #mu and  #sigma 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.

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

TH1F* Integrate(TH1F* histogram, Float_t mean = 0, Float_t sigma = 0, Float_t sigmaMax = 0, Float_t sigmaStep = -1)
 Creates an integrated histogram S(t, #mu, #sigma), out of the input distribution distribution f(x, #mu, #sigma), given in "histogram"
 "mean" and "sigma" are #mu and  #sigma 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.

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

output of MACRO_AliBaseCalibViewer_Integrate_2_5_macro_example_canvas_Integrate
     {
     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);
     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);
     macro_example_canvas->Divide(0,2);
     TVirtualPad *pad1 = macro_example_canvas->cd(1);
     pad1->SetGridy();
     pad1->SetGridx();
     distribution->Draw();
     TVirtualPad *pad2 = macro_example_canvas->cd(2);
     pad2->SetGridy();
     pad2->SetGridx();
     TH1F *shist = AliTPCCalibViewer::Integrate(distribution, mean, sigma, sigmaMax);
     shist->SetNameTitle("Cumulative","Cumulative S(t, #mu, #sigma)");
     shist->Draw();  

     return macro_example_canvas_Integrate;
     }  
     

TH1F* Integrate(Int_t n, Float_t* array, Int_t nbins, Float_t binLow, Float_t binUp, Float_t mean = 0, Float_t sigma = 0, Float_t sigmaMax = 0, Float_t sigmaStep = -1)
 Creates an integrated histogram S(t, #mu, #sigma), out of the input distribution distribution f(x, #mu, #sigma), given in "histogram"
 "mean" and "sigma" are #mu and  #sigma 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
 Here the actual work is done.
void DrawLines(TH1F* cutHistoMean, 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

void 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

TString& GetAbbreviation()
{ return fAbbreviation; }
TString& GetAppendString()
{ return fAppendString; }
void SetAbbreviation(const Char_t* abr)
{ fAbbreviation = abr; }
void SetAppendString(const Char_t* str)
{ fAppendString = str; }
void Draw(Option_t* opt = "")
virtual void GetTimeInfoOCDB(const Char_t* runList, const Char_t* outFile,
Int_t firstRun, Int_t lastRun, UInt_t infoFlags,
const Char_t* ocdbStorage) = 0;
{ fTree->Draw(opt); }
Long64_t Draw(const Char_t* varexp, const TCut& selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
Long64_t Draw(const Char_t* varexp, const Char_t* selection, Option_t* option = "", Long64_t nentries = 1000000000, Long64_t firstentry = 0)
const char* AddAbbreviations(Char_t* c, Bool_t printDrawCommand = kFALSE)
 easy drawing of data, use '~' for abbreviation of '.fElements'
Int_t EasyDraw(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, const Char_t* drawOptions = 0, Bool_t writeDrawCommand = kFALSE) const
 easy drawing of data, use '~' for abbreviation of '.fElements'
 easy drawing of data, use '~' for abbreviation of '.fElements'
Int_t EasyDraw1D(const Char_t* drawCommand, const Char_t* sector, const Char_t* cuts = 0, const Char_t* drawOptions = 0, Bool_t writeDrawCommand = kFALSE) const
 easy drawing of data, use '~' for abbreviation of '.fElements'
 formats title and axis labels of histo, removes '.fElements'
TObjArray* GetListOfVariables(Bool_t printList = kFALSE)
TObjArray* GetListOfNormalizationVariables(Bool_t printList = kFALSE) const
TFriendElement* AddFriend(const Char_t* treename, const Char_t* filename)
{return fTree->AddFriend(treename, filename);}
TFriendElement* AddFriend(TTree* tree, const Char_t* alias, Bool_t warn = kFALSE)
{return fTree->AddFriend(tree, alias, warn);}
TFriendElement* AddFriend(const Char_t* treename, TFile* file)
{return fTree->AddFriend(treename, file);}
TTree * GetTree() const
{ return fTree;}