some fixes/improvements while moving to new ESD format
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 11 Jan 2008 08:28:52 +0000 (08:28 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 11 Jan 2008 08:28:52 +0000 (08:28 +0000)
16 files changed:
PWG0/dNdEta/AliMultiplicityCorrection.cxx
PWG0/dNdEta/AliMultiplicityCorrection.h
PWG0/dNdEta/AlidNdEtaCorrectionSelector.cxx
PWG0/dNdEta/AlidNdEtaCorrectionTask.cxx
PWG0/dNdEta/AlidNdEtaTask.cxx
PWG0/dNdEta/CreateCuts.C
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/plotsMultiplicity.C
PWG0/dNdEta/run.C
PWG0/dNdEta/runCorrection.C
PWG0/dNdEta/runMultiplicitySelector.C
PWG0/dNdEta/rundNdEtaAnalysis.C
PWG0/esdTrackCuts/run.C
PWG0/highMultiplicity/AliHighMultiplicitySelector.cxx
PWG0/highMultiplicity/AliHighMultiplicitySelector.h
PWG0/multiplicity/run.C

index 0041897..c96b548 100644 (file)
@@ -314,7 +314,28 @@ Bool_t AliMultiplicityCorrection::LoadHistograms(const Char_t* dir)
   if (!gDirectory->cd(dir))
     return kFALSE;
 
-  // TODO memory leak. old histograms needs to be deleted.
+  // store old hists to delete them later
+  TList oldObjects;
+  oldObjects.SetOwner(1);
+  for (Int_t i = 0; i < kESDHists; ++i)
+    if (fMultiplicityESD[i])
+      oldObjects.Add(fMultiplicityESD[i]);
+
+  for (Int_t i = 0; i < kMCHists; ++i)
+  {
+    if (fMultiplicityVtx[i])
+      oldObjects.Add(fMultiplicityVtx[i]);
+    if (fMultiplicityMB[i])
+      oldObjects.Add(fMultiplicityMB[i]);
+    if (fMultiplicityINEL[i])
+      oldObjects.Add(fMultiplicityINEL[i]);
+  }
+
+  for (Int_t i = 0; i < kCorrHists; ++i)
+    if (fCorrelation[i])
+      oldObjects.Add(fCorrelation[i]);
+
+  // load histograms
 
   Bool_t success = kTRUE;
 
@@ -346,18 +367,24 @@ Bool_t AliMultiplicityCorrection::LoadHistograms(const Char_t* dir)
 
   gDirectory->cd("..");
 
+  // delete old hists
+  oldObjects.Delete();
+
   return success;
 }
 
 //____________________________________________________________________
-void AliMultiplicityCorrection::SaveHistograms()
+void AliMultiplicityCorrection::SaveHistograms(const char* dir)
 {
   //
   // saves the histograms
   //
 
-  gDirectory->mkdir(GetName());
-  gDirectory->cd(GetName());
+  if (!dir)
+    dir = GetName();
+
+  gDirectory->mkdir(dir);
+  gDirectory->cd(dir);
 
   for (Int_t i = 0; i < kESDHists; ++i)
     if (fMultiplicityESD[i])
@@ -1325,7 +1352,8 @@ void AliMultiplicityCorrection::DrawComparison(const char* name, Int_t inputRang
 
   // scale to 1
   mcHist->Sumw2();
-  mcHist->Scale(1.0 / mcHist->Integral());
+  if (mcHist->Integral() > 0)
+    mcHist->Scale(1.0 / mcHist->Integral());
 
   // calculate residual
 
@@ -1706,7 +1734,7 @@ void AliMultiplicityCorrection::DrawComparison(const char* name, Int_t inputRang
     else
       fLastChi2MC = -1;
 
-    Printf("Chi2 (full range) from (MC - Unfolded) / e(MC) is: %.2f ndf is %d --> chi2 / ndf = %.2f", newChi2, ndf, newChi2 / ndf);
+    Printf("Chi2 (full range) from (MC - Unfolded) / e(MC) is: %.2f ndf is %d --> chi2 / ndf = %.2f", newChi2, ndf, ((ndf > 0) ? newChi2 / ndf : -1));
 
     diffMCUnfolded2->SetTitle("#chi^{2};Npart;(MC - Unfolded) / e(MC)");
     //diffMCUnfolded->GetYaxis()->SetRangeUser(-20, 20);
index 95df174..99ff37b 100644 (file)
@@ -46,7 +46,7 @@ class AliMultiplicityCorrection : public TNamed {
     void FillCorrection(Float_t vtx, Int_t generated05, Int_t generated10, Int_t generated15, Int_t generated20, Int_t generatedAll, Int_t measured05, Int_t measured10, Int_t measured15, Int_t measured20);
 
     Bool_t LoadHistograms(const Char_t* dir = 0);
-    void SaveHistograms();
+    void SaveHistograms(const char* dir = 0);
     void DrawHistograms();
     void DrawComparison(const char* name, Int_t inputRange, Bool_t fullPhaseSpace, Bool_t normalizeESD, TH1* mcHist, Bool_t simple = kFALSE);
 
index 41b3b30..8c13cb0 100644 (file)
@@ -198,7 +198,6 @@ Bool_t AlidNdEtaCorrectionSelector::Process(Long64_t entry)
 
   AliDebug(AliLog::kDebug+1,"Processing event ...\n");
 
-
   if (AliSelectorRL::Process(entry) == kFALSE)
     return kFALSE;
 
index 67dd58e..adfaafe 100644 (file)
@@ -93,8 +93,6 @@ void AlidNdEtaCorrectionTask::ConnectInputData(Option_t *)
       tree->SetBranchStatus("fTracks.fLabel", 1);
     }
 
-    tree->SetCacheSize(0);
-
     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 
     if (!esdH) {
index 65c9533..9eb8f98 100644 (file)
@@ -106,8 +106,6 @@ void AlidNdEtaTask::ConnectInputData(Option_t *)
       tree->SetBranchStatus("fTracks.fLabel", 1);
     }
 
-    tree->SetCacheSize(0);
-
     AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
 
     if (!esdH) {
@@ -262,6 +260,8 @@ void AlidNdEtaTask::Exec(Option_t*)
       labelArr[inputCount] = TMath::Abs(esdTrack->GetLabel());
       ptArr[inputCount] = esdTrack->Pt();
       ++inputCount;
+
+      Printf("%f", esdTrack->Pt());
     }
   }
   else
index e0e4435..15baf3f 100644 (file)
@@ -11,7 +11,8 @@ AliESDtrackCuts* CreateTrackCuts(Bool_t hists = kTRUE)
 
   esdTrackCuts->SetMinNClustersTPC(50);
   esdTrackCuts->SetMaxChi2PerClusterTPC(3.5);
-  esdTrackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,2);
+  esdTrackCuts->SetMaxCovDiagonalElements(2,2,0.5,0.5,1e99);
+  Printf("WARNING: no cut on 1/pt");
   esdTrackCuts->SetRequireTPCRefit(kTRUE);
 
   esdTrackCuts->SetMinNsigmaToVertex(3);
index b4341dd..08bc84e 100644 (file)
@@ -283,6 +283,9 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
     return;
   }
 
+  //new TCanvas; vtxVsEta->DrawCopy();
+  //vtxVsEta->Rebin2D(1, 4);
+
   const Float_t vertexRange = 9.99;
 
   for (Int_t iEta=1; iEta<=vtxVsEta->GetNbinsY(); iEta++)
@@ -317,12 +320,12 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
       Float_t sumError2 = 0;
       for (Int_t iVtx = vertexBinBegin; iVtx < vertexBinEnd; iVtx++)
       {      
-       if (vtxVsEta->GetBinContent(iVtx, iEta) != 0)
+        if (vtxVsEta->GetBinContent(iVtx, iEta) != 0)
         {
           sum = sum + vtxVsEta->GetBinContent(iVtx, iEta);
 
-         if (sumError2 > 10e30)
-           printf("WARNING: sum of error2 is dangerously large - be prepared for crash... ");
+        if (sumError2 > 10e30)
+          printf("WARNING: sum of error2 is dangerously large - be prepared for crash... ");
 
           sumError2 = sumError2 + TMath::Power(vtxVsEta->GetBinError(iVtx, iEta),2);
         }
@@ -340,23 +343,30 @@ void dNdEtaAnalysis::Finish(AlidNdEtaCorrection* correction, Float_t ptCut, Alid
 
       //printf("Eta: %d Vertex Range: %d %d, Event Count %f, Track Sum: %f, Track Sum corrected: %f\n", iEta, vertexBinBegin, vertexBinEnd, totalEvents, sum, sum / ptCutOffCorrection);
 
-      Float_t dndeta = sum / totalEvents;
-      Float_t error  = TMath::Sqrt(sumError2) / totalEvents;
+      Int_t bin = fdNdEta[vertexPos]->FindBin(vtxVsEta->GetYaxis()->GetBinCenter(iEta));
+      if (bin > 0 && bin < fdNdEta[vertexPos]->GetNbinsX())
+      {
+        Float_t dndeta = sum / totalEvents;
+        Float_t error  = TMath::Sqrt(sumError2) / totalEvents;
 
-      dndeta = dndeta/fdNdEta[vertexPos]->GetBinWidth(iEta);
-      error  = error/fdNdEta[vertexPos]->GetBinWidth(iEta);
+        dndeta = dndeta / fdNdEta[vertexPos]->GetBinWidth(bin);
+        error  = error / fdNdEta[vertexPos]->GetBinWidth(bin);
 
-      fdNdEta[vertexPos]->SetBinContent(iEta, dndeta);
-      fdNdEta[vertexPos]->SetBinError(iEta, error);
+        fdNdEta[vertexPos]->SetBinContent(bin, dndeta);
+        fdNdEta[vertexPos]->SetBinError(bin, error);
 
-      dndeta /= ptCutOffCorrection;
-      error  /= ptCutOffCorrection;
+        dndeta /= ptCutOffCorrection;
+        error  /= ptCutOffCorrection;
 
-      fdNdEtaPtCutOffCorrected[vertexPos]->SetBinContent(iEta, dndeta);
-      fdNdEtaPtCutOffCorrected[vertexPos]->SetBinError(iEta, error);
+        fdNdEtaPtCutOffCorrected[vertexPos]->SetBinContent(bin, dndeta);
+        fdNdEtaPtCutOffCorrected[vertexPos]->SetBinError(bin, error);
 
+        Printf("Bin %d has dN/deta = %f", bin, dndeta);
+      }
     }
   }
+
+  new TCanvas; fdNdEta[0]->DrawCopy();
 }
 
 //____________________________________________________________________
@@ -432,17 +442,17 @@ void dNdEtaAnalysis::DrawHistograms(Bool_t simple)
 
     canvas->cd(1);
     if (fdNdEtaPtCutOffCorrected[0])
-      fdNdEtaPtCutOffCorrected[0]->Draw();
+      fdNdEtaPtCutOffCorrected[0]->DrawCopy();
 
     if (fdNdEta[0])
     {
       fdNdEta[0]->SetLineColor(kRed);
-      fdNdEta[0]->Draw("SAME");
+      fdNdEta[0]->DrawCopy("SAME");
     }
 
     canvas->cd(2);
     if (fPtDist)
-      fPtDist->Draw();
+      fPtDist->DrawCopy();
   }
 
     // histograms for different vertices?
@@ -467,7 +477,7 @@ void dNdEtaAnalysis::DrawHistograms(Bool_t simple)
         canvas2->cd();
 
         fdNdEtaPtCutOffCorrected[i]->SetLineColor(i+1);
-        fdNdEtaPtCutOffCorrected[i]->Draw((i == 0) ? "" : "SAME");
+        fdNdEtaPtCutOffCorrected[i]->DrawCopy((i == 0) ? "" : "SAME");
         legend->AddEntry(fdNdEtaPtCutOffCorrected[i], (i == 0) ? "Vtx All" : Form("Vtx Bin %d", i-1));
       }
       if (canvas3 && fdNdEta[i])
@@ -475,7 +485,7 @@ void dNdEtaAnalysis::DrawHistograms(Bool_t simple)
         canvas3->cd();
 
         fdNdEta[i]->SetLineColor(i+1);
-        fdNdEta[i]->Draw((i == 0) ? "" : "SAME");
+        fdNdEta[i]->DrawCopy((i == 0) ? "" : "SAME");
       }
     }
 
@@ -501,10 +511,10 @@ void dNdEtaAnalysis::DrawHistograms(Bool_t simple)
     
         clone->Divide(fdNdEtaPtCutOffCorrected[0]);
         clone->GetYaxis()->SetRangeUser(0.95, 1.05);
-        clone->Draw();
+        clone->DrawCopy();
         
         clone2->Divide(fdNdEtaPtCutOffCorrected[0]);
-        clone2->Draw("SAME");
+        clone2->DrawCopy("SAME");
 
         TLine* line = new TLine(-1, 1, 1, 1);
         line->Draw();
index 439eea7..447c939 100644 (file)
@@ -1037,6 +1037,11 @@ void StartingConditions()
 
   //Int_t marker[] = {24, 25, 26, 27, 28, 2, 3, 4, 5};
 
+  TLegend* legend = new TLegend(0.6, 0.7, 0.95, 0.95);
+  legend->SetFillColor(0);
+
+  const char* names[] = { "True", "Measured 1", "Measured 2", "Measured 3", "NBD", "Flat" };
+
   for (Int_t i=0; i<6; ++i)
   {
     Int_t id = i;
@@ -1055,6 +1060,7 @@ void StartingConditions()
     chi2Result->GetYaxis()->SetTitleOffset(1.5);
     //chi2Result->SetMarkerStyle(marker[i]);
     chi2Result->SetLineColor(i+1);
+    chi2Result->SetMarkerColor(i+1);
     chi2Result->SetStats(kFALSE);
 
     bayesResult->SetTitle("b) Bayesian method;true multiplicity;unfolded / MC");
@@ -1062,7 +1068,7 @@ void StartingConditions()
     bayesResult->GetYaxis()->SetRangeUser(0.8, 1.2);
     bayesResult->GetYaxis()->SetTitleOffset(1.5);
     bayesResult->SetStats(kFALSE);
-    bayesResult->SetLineColor(2);
+    //bayesResult->SetLineColor(2);
     bayesResult->SetLineColor(i+1);
 
     canvas->cd(1);
@@ -1075,8 +1081,12 @@ void StartingConditions()
 
     //TLine* line = new TLine(0, 1, 150, 1);
     //line->Draw();
+
+    legend->AddEntry(chi2Result, names[i]);
   }
 
+  canvas->cd(1);
+  legend->Draw();
   canvas->SaveAs(Form("%s.eps", canvas->GetName()));
 }
 
index 5c7e744..d16bb0c 100644 (file)
@@ -9,6 +9,8 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
     gProof->EnablePackage("STEERBase");
     gProof->UploadPackage("ESD");
     gProof->EnablePackage("ESD");
+    gProof->UploadPackage("AOD");
+    gProof->EnablePackage("AOD");
     gProof->UploadPackage("ANALYSIS");
     gProof->EnablePackage("ANALYSIS");
     gProof->UploadPackage("PWG0base");
index 94f2cfa..2fce071 100644 (file)
@@ -8,6 +8,8 @@ void runCorrection(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug =
     gProof->EnablePackage("STEERBase");
     gProof->UploadPackage("ESD");
     gProof->EnablePackage("ESD");
+    gProof->UploadPackage("AOD");
+    gProof->EnablePackage("AOD");
     gProof->UploadPackage("ANALYSIS");
     gProof->EnablePackage("ANALYSIS");
     gProof->UploadPackage("PWG0base");
@@ -19,6 +21,7 @@ void runCorrection(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug =
     gSystem->Load("libTree");
     gSystem->Load("libSTEERBase");
     gSystem->Load("libESD");
+    gSystem->Load("libAOD");
     gSystem->Load("libANALYSIS");
     gSystem->Load("libPWG0base");
   }
index a52d2b7..5adeb7d 100644 (file)
@@ -190,6 +190,10 @@ void fitOther(const char* fileNameMC = "multiplicityMC_3M.root", const char* fol
   //mult->ApplyMinuitFit(histID, kFALSE);
   //mult->DrawComparison("MinuitChi2", histID, kFALSE, kTRUE, hist2->ProjectionY());
 
+  TFile* file = TFile::Open("out.root", "RECREATE");
+  mult->SaveHistograms();
+  file->Write();
+  file->Close();
 }
 
 void* fit2Step(const char* fileNameMC = "multiplicityMC_2M.root", const char* fileNameESD = "multiplicityMC_1M_3.root", Int_t histID = 3, Bool_t fullPhaseSpace = kFALSE)
index b653112..7acd8e4 100644 (file)
@@ -128,7 +128,7 @@ void FinishAnalysisAll(const char* dataInput = "analysis_esd_raw.root", const ch
   fdNdEtaAnalysis->SaveHistograms();
 }
 
-void FinishAnalysis(const char* analysisFile = "analysis_esd.root", const char* analysisDir = "dndeta", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction", Bool_t useUncorrected = kFALSE, Bool_t simple = kFALSE)
+void* FinishAnalysis(const char* analysisFile = "analysis_esd.root", const char* analysisDir = "dndeta", const char* correctionMapFile = "correction_map.root", const char* correctionMapFolder = "dndeta_correction", Bool_t useUncorrected = kFALSE, Bool_t simple = kFALSE)
 {
   loadlibs();
 
@@ -147,6 +147,8 @@ void FinishAnalysis(const char* analysisFile = "analysis_esd.root", const char*
     fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0, AlidNdEtaCorrection::kINEL);
     //fdNdEtaAnalysis->Finish(dNdEtaCorrection, 0, AlidNdEtaCorrection::kTrack2Particle);
   }
+  else
+    fdNdEtaAnalysis->Finish(0, 0, AlidNdEtaCorrection::kNone);
 
   fdNdEtaAnalysis->DrawHistograms(simple);
 
@@ -158,5 +160,8 @@ void FinishAnalysis(const char* analysisFile = "analysis_esd.root", const char*
   hist = fdNdEtaAnalysis->GetdNdEtaHistogram(2);
   Float_t value2 = hist->Integral(binLeft, binRight);
 
-  printf("Ratio is %f, values are %f %f\n", value1 / value2, value1, value2);
+  if (value2 > 0)
+    printf("Ratio is %f, values are %f %f\n", value1 / value2, value1, value2);
+
+  return fdNdEtaAnalysis;
 }
index 8d94bc1..f4b201a 100644 (file)
@@ -9,6 +9,8 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
     gProof->EnablePackage("STEERBase");
     gProof->UploadPackage("ESD");
     gProof->EnablePackage("ESD");
+    gProof->UploadPackage("AOD");
+    gProof->EnablePackage("AOD");
     gProof->UploadPackage("ANALYSIS");
     gProof->EnablePackage("ANALYSIS");
     gProof->UploadPackage("PWG0base");
@@ -20,6 +22,7 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
     gSystem->Load("libTree");
     gSystem->Load("libSTEERBase");
     gSystem->Load("libESD");
+    gSystem->Load("libAOD");
     gSystem->Load("libANALYSIS");
     gSystem->Load("libPWG0base");
   }
index 1ecd9c1..8e5eba0 100644 (file)
@@ -1103,11 +1103,11 @@ void AliHighMultiplicitySelector::Contamination()
             triggerRate2 += ((mult2 > mult) ? 2. : 1.) * xSection[mult] * xSection[mult2] * triggerEff[mult+mult2];
 
       triggerRate2 *= TMath::Poisson(2, collPerWindow) * windowsPerSecond;
-      //triggerRate2 *= collPerWindow * rate;
 
       Printf("Rate for 2 collisions is %f Hz --> %.1f%%", triggerRate2, triggerRate2 / triggerRate * 100);
 
       Double_t triggerRate3 = 0;
+
       for (Int_t mult = 0; mult < max; mult++)
         for (Int_t mult2 = mult; mult2 < max-mult; mult2++)
           for (Int_t mult3 = 0; mult3 < max-mult-mult2; mult3++)
@@ -1182,6 +1182,101 @@ void AliHighMultiplicitySelector::Contamination()
   }
 }
 
+void AliHighMultiplicitySelector::Contamination2()
+{
+  //
+  // produces a spectrum created with N triggers
+  // number of triggers and thresholds for the moment fixed
+  //
+
+  /*
+
+  gSystem->Load("libANALYSIS");
+  gSystem->Load("libPWG0base");
+  .L AliHighMultiplicitySelector.cxx+g
+  x = new AliHighMultiplicitySelector();
+  x->ReadHistograms("highmult_hijing100k.root");
+  x->Contamination2();
+
+  */
+
+  // get x-sections
+  TFile* file = TFile::Open("crosssectionEx.root");
+  if (!file)
+    return;
+
+  TH1* xSections[2];
+  xSections[0] = dynamic_cast<TH1*> (gFile->Get("xSection2Ex"));
+  xSections[1] = dynamic_cast<TH1*> (gFile->Get("xSection15Ex"));
+
+  Int_t nCuts = 4;
+  Int_t cuts[] = { 104, 134, 154, 170 };
+
+  new TCanvas;
+
+  Int_t colors[] = { 2, 3, 4, 6, 7, 8 };
+  Int_t markers[] = { 7, 2, 4, 5, 6, 27 };
+
+  // put to 2 for second layer
+  for (Int_t i=0; i<1; ++i)
+  {
+    if (!xSections[i])
+      continue;
+
+    // relative x-section, once we have a collision
+    xSections[i]->Scale(1.0 / xSections[i]->Integral());
+
+    Int_t max = xSections[i]->GetNbinsX();
+    max = 500;
+
+    Float_t* xSection = new Float_t[max];
+    for (Int_t mult = 0; mult < max; mult++)
+      xSection[mult] = xSections[i]->GetBinContent(mult+1);
+
+    TH2* fMvsL = (i == 0) ? fMvsL1: fMvsL2;
+
+    for (Int_t currentCut = 0; currentCut<nCuts; ++currentCut)
+    {
+      TGraph* graph = new TGraph;
+      graph->SetMarkerColor(colors[currentCut]);
+      graph->SetMarkerStyle(markers[currentCut]);
+
+      Int_t cut = cuts[currentCut];
+
+      TH1* triggerEffHist = (TH1*) GetTriggerEfficiency(fMvsL, cut)->Clone("triggerEff");
+      Float_t* triggerEff = new Float_t[max];
+      for (Int_t mult = 0; mult < max; mult++)
+        triggerEff[mult] = triggerEffHist->GetBinContent(mult+1);
+
+      Double_t triggerRate = 0;
+      for (Int_t mult = 0; mult < max; mult++)
+        triggerRate += xSection[mult] * triggerEff[mult];
+
+      Printf("Raw value for 1 collision is %e", triggerRate);
+
+      Double_t triggerRate2 = 0;
+      for (Int_t mult = 0; mult < max; mult++)
+        for (Int_t mult2 = mult; mult2 < max; mult2++)
+          if (mult+mult2 < max)
+            triggerRate2 += ((mult2 > mult) ? 2. : 1.) * xSection[mult] * xSection[mult2] * triggerEff[mult+mult2];
+
+      Printf("Raw value for 2 collisions is %e", triggerRate2);
+
+      for (Double_t doubleRate = 0; doubleRate <= 0.2; doubleRate += 0.005)
+      {
+        Float_t totalContamination = (triggerRate2 * doubleRate) / (triggerRate + triggerRate2 * doubleRate);
+
+        //Printf("Total contamination is %.1f%%", totalContamination * 100);
+
+        graph->SetPoint(graph->GetN(), doubleRate, totalContamination);
+      }
+
+      graph->Draw((currentCut == 0) ? "A*" : "* SAME");
+      graph->GetXaxis()->SetRangeUser(0, 1);
+    }
+  }
+}
+
 void AliHighMultiplicitySelector::DrawHistograms()
 {
   // draws the histograms
@@ -1569,6 +1664,8 @@ void AliHighMultiplicitySelector::MBComparison()
             triggerLimit = (Int_t) triggerEff->GetXaxis()->GetBinCenter(bin);
 
         Printf("   Efficiency limit (50%%) is at multiplicity %d", triggerLimit);
+        Float_t fractionGood = proj->Integral(triggerLimit, proj->GetNbinsX()) / proj->Integral();
+        Printf("   %.2f %% of the events are above the trigger limit", fractionGood * 100);
 
         if (triggerLimit > limit)
           Printf("   WARNING: interesting events also counted inside the trigger limit");
index 4cbe307..bad641a 100644 (file)
@@ -36,6 +36,7 @@ class AliHighMultiplicitySelector : public AliSelectorRL {
     void Ntrigger(Bool_t relative = kTRUE);
     TGraph* IntFractRate();
     void Contamination();
+    void Contamination2();
     void MBComparison();
 
  protected:
index 69aa6e9..fc7b08f 100644 (file)
@@ -9,6 +9,8 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
     gProof->EnablePackage("STEERBase");
     gProof->UploadPackage("ESD");
     gProof->EnablePackage("ESD");
+    gProof->UploadPackage("AOD");
+    gProof->EnablePackage("AOD");
     gProof->UploadPackage("ANALYSIS");
     gProof->EnablePackage("ANALYSIS");
     gProof->UploadPackage("PWG0base");
@@ -52,7 +54,7 @@ void run(Char_t* data, Int_t nRuns=20, Int_t offset=0, Bool_t aDebug = kFALSE, B
 
   task = new AliMultiplicityTask(option);
   task->SetTrackCuts(esdTrackCuts);
-  task->SetAnalysisMode(AliMultiplicityTask::kTPC);
+  task->SetAnalysisMode(AliMultiplicityTask::kSPD);
 
   if (mc)
     task->SetReadMC();