Fixes for coverity checks.
[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliFMDCorrELossFit.cxx
index e3f4218..872ee73 100644 (file)
@@ -203,6 +203,7 @@ AliFMDCorrELossFit::ELossFit::operator=(const ELossFit& o)
   // Return:
   //    Reference to this object 
   //
+  if (&o == this) return *this; 
   fN      = o.fN;
   fNu     = o.fNu;
   fChi2           = o.fChi2;
@@ -513,6 +514,26 @@ AliFMDCorrELossFit::ELossFit::Draw(Option_t* option)
 #define CHECKPAR(V,E,T) ((V > 0) && (E / V < T))
 
 //____________________________________________________________________
+Double_t
+AliFMDCorrELossFit::ELossFit::GetLowerBound(Double_t f) const
+{
+  // 
+  // Return 
+  //    Delta * f
+  return f * fDelta;
+}
+//____________________________________________________________________
+Double_t
+AliFMDCorrELossFit::ELossFit::GetLowerBound(Double_t f, 
+                                           Bool_t includeSigma) const
+{
+  // 
+  // Return 
+  //    Delta - f * (xi + sigma)
+  return fDelta - f * (fXi + (includeSigma ? fSigma : 0));
+}
+
+//____________________________________________________________________
 void 
 AliFMDCorrELossFit::ELossFit::CalculateQuality(Double_t maxChi2nu, 
                                               Double_t maxRelError, 
@@ -586,6 +607,7 @@ AliFMDCorrELossFit::operator=(const AliFMDCorrELossFit& o)
   // Return:
   //    Reference to this object 
   //
+  if (&o == this) return *this; 
   fRings = o.fRings;
   fLowCut = o.fLowCut;
   SetEtaAxis(o.fEtaAxis.GetNbins(), o.fEtaAxis.GetXmin(), o.fEtaAxis.GetXmax());
@@ -804,24 +826,24 @@ AliFMDCorrELossFit::FindFit(UShort_t  d, Char_t r, Int_t etabin) const
     return 0;
   }
   if (etabin <= 0 || etabin >= fEtaAxis.GetNbins()) { 
-    AliError(Form("Eta bin=%3d out of bounds [%d,%d] for FMD%d%c", 
-                 etabin, 1, fEtaAxis.GetNbins(), d, r));
+    // AliError(Form("Eta bin=%3d out of bounds [%d,%d] for FMD%d%c", 
+    //              etabin, 1, fEtaAxis.GetNbins(), d, r));
     return 0;
   }
   if (etabin > ringArray->GetEntriesFast()) { 
-    AliError(Form("Eta bin=%3d out of bounds [%d,%d] for FMD%d%c", 
-                 etabin, 1, ringArray->GetEntriesFast(), d, r));
+    // AliError(Form("Eta bin=%3d out of bounds [%d,%d] for FMD%d%c", 
+    //                      etabin, 1, ringArray->GetEntriesFast(), d, r));
     return 0;
   }
   else if (etabin >= ringArray->GetEntriesFast()) { 
-    AliWarning(Form("Eta bin=%3d out of bounds by +1 [%d,%d] for FMD%d%c, " 
-                   "trying %3d", etabin, 1, ringArray->GetEntriesFast(), d, r,
-                   etabin-1));
+    // AliWarning(Form("Eta bin=%3d out of bounds by +1 [%d,%d] for FMD%d%c, " 
+    //             "trying %3d", etabin, 1, ringArray->GetEntriesFast(), d, r,
+    //             etabin-1));
     etabin--;
   }
   else if (!ringArray->At(etabin)) { 
-    AliWarning(Form("Eta bin=%d has no fit for FMD%d%c, trying %03d", 
-                   etabin, d, r, etabin+1));
+    // AliWarning(Form("Eta bin=%d has no fit for FMD%d%c, trying %03d", 
+    //                     etabin, d, r, etabin+1));
     etabin++;
   }
   return static_cast<ELossFit*>(ringArray->At(etabin));
@@ -898,6 +920,56 @@ AliFMDCorrELossFit::GetOrMakeRingArray(UShort_t d, Char_t r)
   return static_cast<TObjArray*>(fRings.At(idx));
 }
 
+//____________________________________________________________________
+Double_t
+AliFMDCorrELossFit::GetLowerBound(UShort_t  d, Char_t r, Int_t etabin,
+                                 Double_t f) const
+{
+  ELossFit* fit = GetFit(d, r, etabin);
+  if (!fit) return -1024;
+  return fit->GetLowerBound(f);
+}
+//____________________________________________________________________
+Double_t
+AliFMDCorrELossFit::GetLowerBound(UShort_t  d, Char_t r, Double_t eta,
+                                 Double_t f) const
+{
+  Int_t bin = FindEtaBin(eta);
+  if (bin <= 0) return -1024;
+  return GetLowerBound(d, r, Int_t(bin), f);
+}
+//____________________________________________________________________
+Double_t
+AliFMDCorrELossFit::GetLowerBound(UShort_t  d, Char_t r, Int_t etabin,
+                                 Double_t f, Bool_t showErrors, 
+                                 Bool_t includeSigma) const
+{
+  ELossFit* fit = GetFit(d, r, etabin);
+  if (!fit) { 
+    if (showErrors) {
+      AliWarning(Form("No fit for FMD%d%c @ etabin=%d", d, r, etabin));
+    }
+    return -1024;
+  }
+  return fit->GetLowerBound(f, includeSigma);
+}
+
+//____________________________________________________________________
+Double_t
+AliFMDCorrELossFit::GetLowerBound(UShort_t  d, Char_t r, Double_t eta,
+                                 Double_t f, Bool_t showErrors, 
+                                 Bool_t includeSigma) const
+{
+  Int_t bin = FindEtaBin(eta);
+  if (bin <= 0) { 
+    if (showErrors)
+      AliError(Form("eta=%f out of bounds for FMD%d%c", eta, d, r));
+    return -1024;
+  }
+  return GetLowerBound(d, r, bin, f, showErrors, includeSigma);
+}
+
+//____________________________________________________________________
 namespace { 
   TH1D* MakeHist(const TAxis& axis, const char* name, const char* title, 
                 Int_t color)
@@ -916,42 +988,17 @@ namespace {
   }
 }
 
+  
+
 #define IDX2RING(I) (i == 0 || i == 1 || i == 3 ? 'I' : 'O')
 #define IDX2DET(I)  (i == 0 ? 1 : (i == 1 || i == 2 ? 2 : 3))
 //____________________________________________________________________
-void
-AliFMDCorrELossFit::Draw(Option_t* option)
+TList*
+AliFMDCorrELossFit::GetStacks(Bool_t err, Bool_t rel, UShort_t maxN) const
 {
-  // 
-  // Draw this object 
-  // 
-  // Parameters:
-  //    option Options.  Possible values are 
-  //  - err Plot error bars 
-  //
-  TString opt(Form("nostack %s", option));
-  opt.ToLower();
-  Bool_t  rel = (opt.Contains("relative"));
-  Bool_t  err = (opt.Contains("error"));
-  if (rel) opt.ReplaceAll("relative","");
-  if (err) opt.ReplaceAll("error","");
-  Int_t    nRings = fRings.GetEntriesFast();
-  UShort_t maxN   = 0;
-  for (Int_t i = 0; i < nRings; i++) { 
-    if (!fRings.At(i)) continue;
-    TObjArray* a     = static_cast<TObjArray*>(fRings.At(i));
-    Int_t      nFits = a->GetEntriesFast();
-
-    for (Int_t j = 0; j < nFits; j++) {
-      ELossFit* fit = static_cast<ELossFit*>(a->At(j));
-      if (!fit) continue;
-      maxN          = TMath::Max(maxN, UShort_t(fit->fN));
-    }
-  }
-  // AliInfo(Form("Maximum N is %d", maxN));
-  Int_t nPad = 6+maxN-1; // 7 regular params, and maxN-1 weights
-  TVirtualPad* pad = gPad;
-  pad->Divide(2, (nPad+1)/2, 0.1, 0, 0);
+  // Get a list of THStacks 
+  Int_t nRings = fRings.GetEntriesFast();
+  Int_t nPad   = 6+maxN-1; // 7 regular params, and maxN-1 weights
 
   enum { 
     kChi2nu = 0, 
@@ -969,18 +1016,18 @@ AliFMDCorrELossFit::Draw(Option_t* option)
   THStack* sSigma;
   // THStack* sigman;
   THStack* n;
-  TList stacks;
-  stacks.AddAt(sChi2nu= new THStack("chi2",   "#chi^{2}/#nu"), kChi2nu);
-  stacks.AddAt(sC     = new THStack("c",       "C"),           kC);
-  stacks.AddAt(sDelta = new THStack("delta",  "#Delta_{mp}"),  kDelta);
-  stacks.AddAt(sXi    = new THStack("xi",     "#xi"),          kXi);
-  stacks.AddAt(sSigma = new THStack("sigma",  "#sigma"),       kSigma);
-  //stacks.AddAt(sigman= new THStack("sigman", "#sigma_{n}"),   5);
-  stacks.AddAt(n     = new THStack("n",      "N"),            kN);
+  TList* stacks = new TList;
+  stacks->AddAt(sChi2nu= new THStack("chi2",   "#chi^{2}/#nu"), kChi2nu);
+  stacks->AddAt(sC     = new THStack("c",       "C"),           kC);
+  stacks->AddAt(sDelta = new THStack("delta",  "#Delta_{mp}"),  kDelta);
+  stacks->AddAt(sXi    = new THStack("xi",     "#xi"),          kXi);
+  stacks->AddAt(sSigma = new THStack("sigma",  "#sigma"),       kSigma);
+  //stacks->AddAt(sigman= new THStack("sigman", "#sigma_{n}"),   5);
+  stacks->AddAt(n     = new THStack("n",      "N"),            kN);
   for (Int_t i = 1; i <= maxN; i++) {
-    stacks.AddAt(new THStack(Form("a_%02d", i+1), Form("a_{%d}", i+1)), kN+i);
+    stacks->AddAt(new THStack(Form("a_%02d", i+1), Form("a_{%d}", i+1)), kN+i);
   }
-
+  
   TArrayD min(nPad);
   TArrayD max(nPad);
   min.Reset(100000);
@@ -1015,7 +1062,7 @@ AliFMDCorrELossFit::Draw(Option_t* option)
 
     for (Int_t k = 1; k <= maxN; k++) { 
       hA[k-1] = MakeHist(fEtaAxis,a->GetName(), Form("a%02d",k+1), color);
-      static_cast<THStack*>(stacks.At(kN+k))->Add(hA[k-1], ho);
+      static_cast<THStack*>(stacks->At(kN+k))->Add(hA[k-1], ho);
     }
                          
     for (Int_t j = 0; j < nFits; j++) {
@@ -1085,6 +1132,47 @@ AliFMDCorrELossFit::Draw(Option_t* option)
       }
     }
   }
+  return stacks;
+}
+
+//____________________________________________________________________
+void
+AliFMDCorrELossFit::Draw(Option_t* option)
+{
+  // 
+  // Draw this object 
+  // 
+  // Parameters:
+  //    option Options.  Possible values are 
+  //  - err Plot error bars 
+  //
+  TString opt(Form("nostack %s", option));
+  opt.ToLower();
+  Bool_t  rel = (opt.Contains("relative"));
+  Bool_t  err = (opt.Contains("error"));
+  if (rel) opt.ReplaceAll("relative","");
+  if (err) opt.ReplaceAll("error","");
+
+  UShort_t maxN   = 0;
+  Int_t nRings = fRings.GetEntriesFast();
+  for (Int_t i = 0; i < nRings; i++) { 
+    if (!fRings.At(i)) continue;
+    TObjArray* a     = static_cast<TObjArray*>(fRings.At(i));
+    Int_t      nFits = a->GetEntriesFast();
+
+    for (Int_t j = 0; j < nFits; j++) {
+      ELossFit* fit = static_cast<ELossFit*>(a->At(j));
+      if (!fit) continue;
+      maxN          = TMath::Max(maxN, UShort_t(fit->fN));
+    }
+  }
+  // AliInfo(Form("Maximum N is %d", maxN));
+  Int_t nPad = 6+maxN-1; // 7 regular params, and maxN-1 weights
+  TVirtualPad* pad = gPad;
+  pad->Divide(2, (nPad+1)/2, 0.1, 0, 0);
+
+  TList* stacks = GetStacks(err, rel, maxN);
+
   Int_t nPad2 = (nPad+1) / 2;
   for (Int_t i = 0; i < nPad; i++) {
     Int_t iPad = 1 + i/nPad2 + 2 * (i % nPad2);
@@ -1096,11 +1184,13 @@ AliFMDCorrELossFit::Draw(Option_t* option)
     p->SetGridy();
     if (rel && i != 0 && i != 6 && i != 5 && i != 4) p->SetLogy();
 
-    Double_t powMax = TMath::Log10(max[i]);
-    Double_t powMin = min[i] <= 0 ? powMax : TMath::Log10(min[i]);
-    if (powMax-powMin > 2. && min[i] != 0) p->SetLogy();
 
-    THStack* stack = static_cast<THStack*>(stacks.At(i));
+    THStack* stack = static_cast<THStack*>(stacks->At(i));
+
+    // Double_t powMax = TMath::Log10(max[i]);
+    // Double_t powMin = min[i] <= 0 ? powMax : TMath::Log10(min[i]);
+    // if (powMax-powMin > 2. && min[i] != 0) p->SetLogy();
+
     // stack->SetMinimum(min[i]);
     // stack->SetMaximum(max[i]);
     stack->Draw(opt.Data());