patch from Markus for 2+1 analysis
authorlmilano <lmilano@cern.ch>
Mon, 24 Nov 2014 17:36:24 +0000 (18:36 +0100)
committerlmilano <lmilano@cern.ch>
Mon, 24 Nov 2014 17:36:24 +0000 (18:36 +0100)
PWGCF/Correlations/Base/AliTwoPlusOneContainer.cxx
PWGCF/Correlations/Base/AliTwoPlusOneContainer.h
PWGCF/Correlations/macros/twoplusone/output_TwoPlusOne.C

index 6a3808a..746515b 100644 (file)
@@ -35,6 +35,7 @@
 #include "AliVParticle.h"
 
 #include "TH1F.h"
+#include "TH2F.h"
 #include "TMath.h"
 
 ClassImp(AliTwoPlusOneContainer)
@@ -42,6 +43,9 @@ ClassImp(AliTwoPlusOneContainer)
 AliTwoPlusOneContainer::AliTwoPlusOneContainer(const char* name, const char* binning, Double_t alpha) : 
   TNamed(name, name),
   fTwoPlusOne(0),
+  fAsymmetry(0),
+  fAsymmetryMixed(0),
+  fTriggerPt(0),
   fTriggerPt1Min(0),
   fTriggerPt1Max(0),
   fTriggerPt2Min(0),
@@ -77,7 +81,13 @@ AliTwoPlusOneContainer::AliTwoPlusOneContainer(const char* name, const char* bin
   fTriggerPt2Max = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(6)->GetXmax();
   fPtAssocMin = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(1)->GetXmin();
   fPtAssocMax = fTwoPlusOne->GetTrackHist(AliUEHist::kToward)->GetGrid((AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS)->GetAxis(1)->GetXmax();
-
+  
+  fAsymmetry  = new TH1F("fAsymmetry", ";A;dN", 50, 0, 1);
+  fAsymmetryMixed  = new TH1F("fAsymmetryMixed", ";A;dN", 50, 0, 1);
+  Int_t pt1_bins = (fTriggerPt1Max - fTriggerPt1Min)/0.1;
+  Int_t pt2_bins = (fTriggerPt2Max - fTriggerPt2Min)/0.1;
+  fTriggerPt = new TH2F("fTriggerPt", ";p_{T,1};p_{T,2}", pt1_bins, fTriggerPt1Min, fTriggerPt1Max, pt2_bins, fTriggerPt2Min, fTriggerPt2Max);
+  
   TH1::AddDirectory();
 }
 
@@ -85,6 +95,9 @@ AliTwoPlusOneContainer::AliTwoPlusOneContainer(const char* name, const char* bin
 AliTwoPlusOneContainer::AliTwoPlusOneContainer(const AliTwoPlusOneContainer &c) :
   TNamed(fName, fTitle),
   fTwoPlusOne(0),
+  fAsymmetry(0),
+  fAsymmetryMixed(0),
+  fTriggerPt(0),
   fTriggerPt1Min(0),
   fTriggerPt1Max(0),
   fTriggerPt2Min(0),
@@ -125,6 +138,24 @@ void AliTwoPlusOneContainer::DeleteContainers()
     delete fTwoPlusOne;
     fTwoPlusOne = 0;
   }
+  
+  if(fAsymmetry)
+  {
+    delete fAsymmetry;
+    fAsymmetry = 0;
+  }
+
+  if(fAsymmetryMixed)
+  {
+    delete fAsymmetryMixed;
+    fAsymmetryMixed = 0;
+  }
+
+  if(fTriggerPt)
+  {
+    delete fTriggerPt;
+    fTriggerPt = 0;
+  }
 }
 
 
@@ -232,6 +263,24 @@ void AliTwoPlusOneContainer::FillCorrelations(Double_t centrality, Float_t zVtx,
            vars[3] = found_particle[k]->Pt();
            event_hist->Fill(vars, stepUEHist+1, weight);//away side
          }
+       
+       //fill fTriggerPt only once, choosed kSameNS
+       if(step==AliTwoPlusOneContainer::kSameNS)
+         for(Int_t k=0; k< ind_found; k++)
+           fTriggerPt->Fill(part_pt, found_particle[k]->Pt());
+
+       //fill asymmetry only for kSameNS and kMixedNS
+       if(step==AliTwoPlusOneContainer::kSameNS||step==AliTwoPlusOneContainer::kMixedNS){
+         for(Int_t k=0; k< ind_found; k++){
+           Float_t asymmetry = (part_pt-found_particle[k]->Pt())/(part_pt+found_particle[k]->Pt());
+           if(step==AliTwoPlusOneContainer::kSameNS){
+             fAsymmetry->Fill(asymmetry);
+           }else{
+             fAsymmetryMixed->Fill(asymmetry);
+           }
+         }
+       }
+         
     }
  
     //add correlated particles on the near side
@@ -336,7 +385,16 @@ void AliTwoPlusOneContainer::Copy(TObject& c) const
 
   if (fTwoPlusOne)
     target.fTwoPlusOne = dynamic_cast<AliUEHist*> (fTwoPlusOne->Clone());
+  
+  if (fAsymmetry)
+    target.fAsymmetry = dynamic_cast<TH1F*> (fAsymmetry->Clone());
 
+  if (fAsymmetryMixed)
+    target.fAsymmetryMixed = dynamic_cast<TH1F*> (fAsymmetryMixed->Clone());
+
+  if (fTriggerPt)
+    target.fTriggerPt = dynamic_cast<TH2F*> (fTriggerPt->Clone());
+  
 }
 
 //____________________________________________________________________
@@ -353,9 +411,13 @@ Long64_t AliTwoPlusOneContainer::Merge(TCollection* list)
 
   TIterator* iter = list->MakeIterator();
   TObject* obj;
-
+  
   // collections of objects
-  TList* lists = new TList;
+  const Int_t kMaxLists = 4;
+  TList* lists[kMaxLists];
+
+  for (Int_t i=0; i<kMaxLists; i++)
+    lists[i] = new TList;
 
   Int_t count = 0;
   while ((obj = iter->Next())) {
@@ -364,15 +426,24 @@ Long64_t AliTwoPlusOneContainer::Merge(TCollection* list)
     if (entry == 0) 
       continue;
 
-    lists->Add(entry->fTwoPlusOne);
+    lists[0]->Add(entry->fTwoPlusOne);
+    lists[1]->Add(entry->fAsymmetry);
+    lists[2]->Add(entry->fAsymmetryMixed);
+    lists[3]->Add(entry->fTriggerPt);
 
     fMergeCount += entry->fMergeCount;
     count++;
   }
   
-  fTwoPlusOne->Merge(lists);
+  fTwoPlusOne->Merge(lists[0]);
+  fAsymmetry->Merge(lists[1]);
+  fAsymmetryMixed->Merge(lists[2]);
+  fTriggerPt->Merge(lists[3]);
+
+  for (Int_t i=0; i<kMaxLists; i++)
+  delete lists[i];
 
-  delete lists;
+  //  delete lists;
   return count+1;
 
 }
index c610158..8905a12 100644 (file)
@@ -31,6 +31,9 @@ class AliTwoPlusOneContainer : public TNamed
   void FillCorrelations(Double_t centrality, Float_t zVtx, AliTwoPlusOneContainer::PlotKind step, TObjArray* triggerNear, TObjArray* triggerAway, TObjArray* assocNear, TObjArray* assocAway, Double_t weight, Bool_t is1plus1, Bool_t isBackgroundSame);
   
   AliUEHist* GetData() {return fTwoPlusOne;}
+  TH1F* GetAsymmetry() {return fAsymmetry;}
+  TH1F* GetAsymmetryMixed() {return fAsymmetryMixed;}
+  TH2F* GetTriggerPt() {return fTriggerPt;}
   Double_t getTriggerPt1Min() {return fTriggerPt1Min;}
   Double_t getTriggerPt1Max() {return fTriggerPt1Max;}
   Double_t getTriggerPt2Min() {return fTriggerPt2Min;}
@@ -49,8 +52,13 @@ class AliTwoPlusOneContainer : public TNamed
 protected:
   void DeleteContainers();
   
-  AliUEHist* fTwoPlusOne;           //a 6 dim histogram which actually contains all the data
-  
+  AliUEHist* fTwoPlusOne;           //a 7 dim histogram which actually contains all the data
+
+  TH1F* fAsymmetry;                  //asymmetry of the same event
+  TH1F* fAsymmetryMixed;             //asymmetry of the mixed event
+
+  TH2F* fTriggerPt;                  //2 dim histogramm with fine binning to describe the pT distribution of the trigger particles
+
   Double_t fTriggerPt1Min;           //minimum energy for the first trigger particle
   Double_t fTriggerPt1Max;           //maximum energy for the first trigger particle
   Double_t fTriggerPt2Min;           //minimum energy for the second trigger particle
@@ -60,7 +68,7 @@ protected:
   Double_t fAlpha;                   //minimum energy for the first trigger particle
   Int_t fMergeCount;                // counts how many objects have been merged together
   
-  ClassDef(AliTwoPlusOneContainer, 3)  // underlying event histogram container
+  ClassDef(AliTwoPlusOneContainer, 4)  // underlying event histogram container
 };
 
 
index afe6084..90985c5 100644 (file)
@@ -8,8 +8,8 @@ Float_t gVertex = 6.9;
 Float_t gZVtxRange = -1;
 Float_t gAxis = 0;
 Float_t gBasisSize = 350;
-Float_t g_phi_bin = 0.32;//bins of 0.174532
-Float_t g_eta_bin = 0.39;//bins of 0.2
+Float_t g_phi_bin = 0.32;//0.32;//bins of 0.174532
+Float_t g_eta_bin = 0.19;//0.39;//bins of 0.2
 
 void loadlibs()
 {
@@ -334,7 +334,7 @@ void peakDifference_side(const char* fileName, double pt1Min = 4.0, double pt1Ma
 
 //mode 0 near and away side (two different multiplicities in the two rows)
 //mode 1 central and semi central (near side in top and away side in bottom row)
-void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, double pt2Min = 2.0, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t side = 0, Int_t yPos = 0, Int_t mode = 0,  Int_t subtractMixedComb = 1, Int_t subtractFlow = 1){
+void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, double pt2Min = 2.0, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t side = 0, Int_t yPos = 0, Int_t mode = 0,  Int_t subtractMixedComb = 1, Int_t subtractFlow = 1, Int_t draw = 0){
 
   static const int pt_assoc_bins_number = 8;
   Double_t pt_assoc_bins[pt_assoc_bins_number] = {0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 10.0};
@@ -358,9 +358,10 @@ void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 1
       near = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, multBinBegin, multBinEnd, 0, 1, 1, 0, subtractMixedComb, subtractFlow)->Clone();
       away = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, multBinBegin, multBinEnd, 1, 2, 1, 0, subtractMixedComb, subtractFlow)->Clone();
       onePlusOne = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, multBinBegin, multBinEnd, 6, 2, 1, 0, subtractMixedComb, subtractFlow);
-      
+       //onePlusOne = (TH1*)getAnalysis(fileName, pt2Min, pt1Min, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, multBinBegin, multBinEnd, 6, 2, 1, 0, subtractMixedComb, subtractFlow);
 
       can = new TCanvas(Form(" %i, mult %i-%i ", i, multBinBegin, multBinEnd), Form(" %i, mult %i-%i ", i, multBinBegin, multBinEnd), i*gBasisSize+100, yPos*(gBasisSize+50), gBasisSize, gBasisSize);
+      
     }else if(mode==1){
       near = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, 1, 5, side, 1, 1, 0, subtractMixedComb, subtractFlow)->Clone();
       away = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, 9, 10, side, 2, 1, 0, subtractMixedComb, subtractFlow);
@@ -371,6 +372,8 @@ void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 1
       return;
     }
     away->SetLineColor(kRed);
+    if(mode==0)
+      onePlusOne->SetLineColor(kGreen);
     
     Int_t bin_start = near->FindBin(-1*g_phi_bin);
     Int_t bin_end = near->FindBin(g_phi_bin);
@@ -382,6 +385,8 @@ void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 1
 
     ((TH1*)(near->Clone()))->DrawCopy();
     ((TH1*)(away->Clone()))->DrawCopy("same");
+    if(mode==0)
+      ((TH1*)(onePlusOne->Clone()))->DrawCopy("same");
 
     if(i==4){
       TLegend* leg = getLegend();
@@ -432,10 +437,20 @@ void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 1
     near_error[i] /= 2*pt_assoc_bin_error[i];
     away_content[i] /= 2*pt_assoc_bin_error[i];
     away_error[i] /= 2*pt_assoc_bin_error[i];
-    onePlusOne_content[i] /= 2*pt_assoc_bin_error[i];
-    onePlusOne_error[i] /= 2*pt_assoc_bin_error[i];
+    if(mode==0){
+      onePlusOne_content[i] /= 2*pt_assoc_bin_error[i];
+      onePlusOne_error[i] /= 2*pt_assoc_bin_error[i];
+    }
   }
-
+  /*
+  //divide content by 1+1 content
+  for(int i=0; i<pt_assoc_bins_number-1; i++){
+    near_content[i] /= onePlusOne_content[i];
+    near_error[i] /= onePlusOne_content[i];
+    away_content[i] /= onePlusOne_content[i];
+    away_error[i] /= onePlusOne_content[i];
+  }
+  */
   TGraphErrors* graph_near = new TGraphErrors(pt_assoc_bins_number, pt_assoc_bin_center, near_content, pt_assoc_bin_error, near_error);
   TGraphErrors* graph_away = new TGraphErrors(pt_assoc_bins_number, pt_assoc_bin_center, away_content, pt_assoc_bin_error, away_error);
   TGraphErrors* graph_onePlusone = new TGraphErrors(pt_assoc_bins_number, pt_assoc_bin_center, onePlusOne_content, pt_assoc_bin_error, onePlusOne_error);
@@ -456,16 +471,20 @@ void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 1
   graph_away->SetMarkerColor(kRed);
   graph_away->SetLineColor(kRed);
   graph_away->SetMarkerStyle(22);
-  graph_onePlusone->GetXaxis()->SetTitle("p_{T,assoc} (GeV/c)");
-  graph_onePlusone->GetYaxis()->SetTitle("1/N dN/dpT");
-  graph_onePlusone->SetMarkerSize(2);
-  graph_onePlusone->SetLineWidth(2);
-  graph_onePlusone->SetMarkerColor(kGreen);
-  graph_onePlusone->SetLineColor(kGreen);
-  graph_onePlusone->SetMarkerStyle(22);
   graph_near->Draw("AP");
   graph_away->Draw("P");
-  graph_onePlusone->Draw("P");
+
+  if(false && mode==0){
+    graph_onePlusone->GetXaxis()->SetTitle("p_{T,assoc} (GeV/c)");
+    graph_onePlusone->GetYaxis()->SetTitle("1/N dN/dpT");
+    graph_onePlusone->SetMarkerSize(2);
+    graph_onePlusone->SetLineWidth(2);
+    graph_onePlusone->SetMarkerColor(kGreen);
+    graph_onePlusone->SetLineColor(kGreen);
+    graph_onePlusone->SetMarkerStyle(22);
+    graph_onePlusone->Draw("P");
+  }
+  gPad->SetLogy();
 
   TLegend* leg2 = getLegend();
   if(mode==0){
@@ -481,10 +500,220 @@ void peakDifference(const char* fileName, double pt1Min = 4.0, double pt1Max = 1
 }
 
 
+
+
+
+
+
+
+
+
+void peakDifference_draw(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, double pt2Min = 2.0, Int_t yPos = 0,  Int_t subtractMixedComb = 1, Int_t subtractFlow = 1){
+
+  TGraphErrors* graph_central_near = (TGraphErrors*)(peakDifference_graph(fileName, pt1Min, pt1Max, pt2Min, 1, 5, 0, yPos, subtractMixedComb, subtractFlow)->Clone());
+  TGraphErrors* graph_central_away = (TGraphErrors*)(peakDifference_graph(fileName, pt1Min, pt1Max, pt2Min, 1, 5, 1, yPos, subtractMixedComb, subtractFlow)->Clone());
+
+  TGraphErrors* graph_semi_near = (TGraphErrors*)(peakDifference_graph(fileName, pt1Min, pt1Max, pt2Min, 9, 10, 0, yPos, subtractMixedComb, subtractFlow)->Clone());
+  TGraphErrors* graph_semi_away = (TGraphErrors*)(peakDifference_graph(fileName, pt1Min, pt1Max, pt2Min, 9, 10, 1, yPos, subtractMixedComb, subtractFlow)->Clone());
+
+  TCanvas* can_graph = new TCanvas(Form("result %i", yPos), Form("result %i", yPos), gBasisSize+50, yPos*(gBasisSize+50), gBasisSize, gBasisSize);
+  /*
+  for(Int_t i=0; i<10; i++){
+    Double_t x;
+    Double_t y;
+    Int_t return_value = graph_central_near->GetPoint(i, x, y);
+
+    printf("point %i, %f %f, returns %i", i, x, y, return_value);
+  }
+  */
+  graph_central_near->Draw("AP");
+  graph_central_away->SetMarkerColor(kRed);
+  graph_central_away->SetLineColor(kRed);
+  graph_central_away->Draw("P");
+  
+  graph_semi_near->SetMarkerColor(kCyan);
+  graph_semi_near->SetLineColor(kCyan);
+  graph_semi_near->Draw("P");
+
+  graph_semi_away->SetMarkerColor(kOrange);
+  graph_semi_away->SetLineColor(kOrange);
+  graph_semi_away->Draw("P");
+
+  gPad->SetLogy();
+
+  TLegend* leg = getLegend();
+  leg->AddEntry(graph_central_near,"central near","l");
+  leg->AddEntry(graph_central_away,"central away side","l");
+  leg->AddEntry(graph_semi_near,"semi central near","l");
+  leg->AddEntry(graph_semi_away,"semi central away","l");
+  leg->Draw("same");
+
+}
+
+TGraphErrors* peakDifference_graph(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, double pt2Min = 2.0, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t side = 0, Int_t yPos = 0, Int_t subtractMixedComb = 1, Int_t subtractFlow = 1, Int_t draw = 0){
+
+  static const int pt_assoc_bins_number = 8;
+  Double_t pt_assoc_bins[pt_assoc_bins_number] = {0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 10.0};
+  Double_t content[pt_assoc_bins_number-1];
+  Double_t error[pt_assoc_bins_number-1];
+
+  Double_t pt_assoc_bin_center[pt_assoc_bins_number-1] = {0.75, 1.5, 2.5, 3.5, 5.0, 7.0, 9.0};
+  Double_t pt_assoc_bin_error[pt_assoc_bins_number-1] = {0.25, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0};
+
+  for(int i=0; i<pt_assoc_bins_number-1; i++){
+    TH1* near = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, multBinBegin, multBinEnd, side, 1, 1, 0, subtractMixedComb, subtractFlow)->Clone();
+    
+    Int_t bin_start = near->FindBin(-1*g_phi_bin);
+    Int_t bin_end = near->FindBin(g_phi_bin);
+
+    content[i] = near->IntegralAndError(bin_start, bin_end, error[i]);
+  }
+
+  //scale content with the bin width
+  for(int i=0; i<pt_assoc_bins_number-1; i++){
+    content[i] /= 2*pt_assoc_bin_error[i];
+    error[i] /= 2*pt_assoc_bin_error[i];
+  }
+
+  TGraphErrors* graph = new TGraphErrors(pt_assoc_bins_number-1, pt_assoc_bin_center, content, pt_assoc_bin_error, error);
+
+  graph->GetXaxis()->SetTitle("p_{T,assoc} (GeV/c)");
+  graph->GetYaxis()->SetTitle("1/N dN/dpT");
+  graph->SetMarkerSize(2);
+  graph->SetLineWidth(3);
+  graph->SetMarkerColor(kBlue);
+  graph->SetLineColor(kBlue);
+  graph->SetMarkerStyle(20);
+
+  return graph;
+  
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+void showAll1plus1(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, double pt2Min = 2.0, Int_t subtractMixedComb = 1, Int_t subtractFlow = 1){
+
+  show1plus1("AnalysisResults_1045.root", pt1Min, pt1Max, 1, 5, 0, subtractFlow);
+
+  show1plus1("AnalysisResults_1045.root", pt1Min, pt1Max, 9, 10, 1, subtractFlow);
+}
+
+void show1plus1(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t yPos = 0, Int_t subtractFlow = 1){
+
+  //for 1+1 there is no mixed comb
+  Int_t subtractMixedComb = 0;
+
+  const int pt1_bins = 2;//(pt1Max-pt1Min)/2;
+  static const int pt1_bins_max = 20;
+
+  if(pt1_bins>pt1_bins_max){
+    printf("error not enough pt1_bins");
+    return;
+  }
+
+  static const int pt_assoc_bins_number = 8;
+  Double_t pt_assoc_bins[pt_assoc_bins_number] = {0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 10.0};
+  Double_t content[pt1_bins_max][pt_assoc_bins_number-1];
+  Double_t error[pt1_bins_max][pt_assoc_bins_number-1];
+
+  Double_t pt_assoc_bin_center[pt_assoc_bins_number-1] = {0.75, 1.5, 2.5, 3.5, 5.0, 7.0, 9.0};
+  Double_t pt_assoc_bin_error[pt_assoc_bins_number-1] = {0.25, 0.5, 0.5, 0.5, 1.0, 1.0, 1.0};
+
+  for(int i=0; i<pt_assoc_bins_number-1; i++){
+    TCanvas* can = new TCanvas(Form("1plus1 %i, pT %i", yPos, i), Form("1plus1 %i, pT %i", yPos, i), i*gBasisSize+50, yPos*(gBasisSize+50), gBasisSize, gBasisSize);
+     
+    TLegend *leg  = getLegend();
+
+    for(int j=0; j<pt1_bins; j++){
+      double pt1Minimum = pt1Min+j*2.0;
+      TH1D* onePlusOne = (TH1*)getAnalysis(fileName, pt1Minimum, pt1Minimum + 2.0, 0, pt_assoc_bins[i], pt_assoc_bins[i+1], 6.9, multBinBegin, multBinEnd, 6, 2, 1, 0, subtractMixedComb, subtractFlow);
+      
+      Int_t bin_start = onePlusOne->FindBin(-1*g_phi_bin);
+      Int_t bin_end = onePlusOne->FindBin(g_phi_bin);
+
+      content[j][i] = onePlusOne->IntegralAndError(bin_start, bin_end, error[j][i]);
+
+      if(j==1)
+       onePlusOne->SetLineColor(kRed);
+      else if(j==2)
+       onePlusOne->SetLineColor(kGreen);
+      else if(j==3)
+       onePlusOne->SetLineColor(kMagenta);
+
+      if(j==0){
+       ((TH1*)(onePlusOne->Clone()))->DrawCopy();
+      }else{
+       ((TH1*)(onePlusOne->Clone()))->DrawCopy("same");
+      }
+
+      leg->AddEntry((TH1*)(onePlusOne->Clone()), Form("pT %.0f", pt1Minimum) ,"l");
+      if(j==pt1_bins-1)
+       leg->Draw("same");
+    }
+  }
+
+
+  TCanvas* can_graph = new TCanvas(Form("result %i", yPos), Form("result %i", yPos), pt_assoc_bins_number*gBasisSize+50, yPos*(gBasisSize+50), gBasisSize, gBasisSize);
+
+  TLegend *leg  = getLegend();
+
+  for(int j=0; j<pt1_bins; j++){
+    TGraphErrors* graph = new TGraphErrors(pt_assoc_bins_number, pt_assoc_bin_center, content[j], pt_assoc_bin_error, error[j]);
+
+    graph->GetXaxis()->SetTitle("p_{T,assoc} (GeV/c)");
+    graph->GetYaxis()->SetTitle("1/N dN/dpT");
+    graph->SetMarkerSize(2);
+    graph->SetLineWidth(2);
+    graph->SetMarkerStyle(20);
+
+    if(j==0){
+      //graph->SetMarkerColor(kCyan);
+      //graph->SetLineColor(kCyan);
+      graph->SetMarkerColor(kBlue);
+      graph->SetLineColor(kBlue);
+      (TGraphErrors*)(graph->Clone())->Draw("AP");
+      //(TGraphErrors*)(graph->Clone())->Draw("P");
+    }else if(j==1){
+      //graph->SetMarkerColor(kOrange);
+      //graph->SetLineColor(kOrange);
+      graph->SetMarkerColor(kRed);
+      graph->SetLineColor(kRed);
+      (TGraphErrors*)(graph->Clone())->Draw("P");
+    }else if(j==2){
+      //graph->SetMarkerColor(kMagenta);
+      //graph->SetLineColor(kMagenta);
+      graph->SetMarkerColor(kGreen);
+      graph->SetLineColor(kGreen);
+      (TGraphErrors*)(graph->Clone())->Draw("P");
+    }
+
+    double pt1Minimum = pt1Min+j*2.0;
+    leg->AddEntry((TGraphErrors*)(graph->Clone()),Form("pT %.0f", pt1Minimum),"l");
+    if(j==pt1_bins-1)
+      leg->Draw("same");
+  }
+  
+
+}
+
+
 //does the reading out of the results
 //divides the same event by the mixed events
 //subtracts the mixed combinatorics
-TH1D* getAnalysis(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Double_t pt2Min = 2.0, Double_t ptAssocMin = 0.5, Double_t ptAssocMax = 8.0, Double_t setVertex = 7, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t step = 0, Int_t posX = 1, Int_t posY = 1, Int_t showPlots = 0, Int_t subtractMixedComb = 0, Int_t subtractFlow =0)
+TH1D* getAnalysis(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Double_t pt2Min = 2.0, Double_t ptAssocMin = 0.5, Double_t ptAssocMax = 8.0, Double_t setVertex = 7, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t step = 0, Int_t posX = 1, Int_t posY = 1, Int_t showPlots = 0, Int_t subtractMixedComb = 0, Int_t subtractFlow =0, Int_t* trigger = NULL)
 {
   loadlibs();
   //to guarantee to pick only the bins from the choosen pt on
@@ -497,9 +726,10 @@ TH1D* getAnalysis(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.
   AliTwoPlusOneContainer* h = (AliTwoPlusOneContainer*) GetTwoPlusOne(fileName);
 
   AliUEHist::CFStep step_same = step;//(AliUEHist::CFStep) AliTwoPlusOneContainer::kSameNS;
-  AliUEHist::CFStep step_mixed = step+2;//(AliUEHist::CFStep) AliTwoPlusOneContainer::kMixedNS;
-  AliUEHist::CFStep step_mixedComb = step+4;//(AliUEHist::CStep) AliTwoPlusOneContainer::kMixedCombNS;
-  AliUEHist::CFStep step_backgroundSame = step+7;//(AliUEHist::CStep) AliTwoPlusOneContainer::kBackgroundSameNS;
+  AliUEHist::CFStep step_mixed = (step%2)+2;//(AliUEHist::CFStep) AliTwoPlusOneContainer::kMixedNS;
+  if(step>=7) step_mixed = ((step+1)%2)+2;
+  AliUEHist::CFStep step_mixedComb = (step%2)+4;//(AliUEHist::CStep) AliTwoPlusOneContainer::kMixedCombNS;
+  AliUEHist::CFStep step_backgroundSame = (step%2)+7;//(AliUEHist::CStep) AliTwoPlusOneContainer::kBackgroundSameNS;
 
   AliUEHist::CFStep step_1plus1 = (AliUEHist::CFStep) AliTwoPlusOneContainer::k1plus1;
   AliUEHist::CFStep step_1plus1_mixed = (AliUEHist::CFStep) AliTwoPlusOneContainer::kMixed1plus1;
@@ -519,11 +749,14 @@ TH1D* getAnalysis(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.
   TH1D* h1_phi_cloneProject;
 
   if(step>=2||!subtractMixedComb){
-    Int_t trigger;
+    Int_t trigger_etaPhi;
     if(step!=6)
-      h2_etaPhi = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_same, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kTRUE, step_mixed, &trigger);
+      h2_etaPhi = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_same, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kTRUE, step_mixed, &trigger_etaPhi);
     else  if(step==6)
-      h2_etaPhi = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_1plus1, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kTRUE, step_1plus1_mixed, &trigger);
+      h2_etaPhi = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_1plus1, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kTRUE, step_1plus1_mixed, &trigger_etaPhi);
+
+    if(trigger!=NULL)
+      *trigger = (Int_t)trigger_etaPhi;
   }else if(step<2 && subtractMixedComb){
     Int_t trigger_same;
     Int_t trigger_mixed_comb;
@@ -536,7 +769,15 @@ TH1D* getAnalysis(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.
     h2_etaPhi_clone->Scale(1.0/trigger_same);
 
     //don't need to use getMixedComb_scaled_backgroundSame, see compareScaledMixedComb which shows that both methods are identical but here getSumOfRatios is used which makes it easier (and safer against errors)
-   h2_etaPhi_mixedComb = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_mixedComb, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kFALSE, step_mixed, &trigger_mixed_comb);
+    //the 1+1 analysis can only be used if the full analysis was done within the same pt bins
+    /*
+    if(step==0)
+      h2_etaPhi_mixedComb = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_1plus1, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kFALSE, step_1plus1_mixed, &trigger_mixed_comb);
+    else if(step==1)
+      h2_etaPhi_mixedComb = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_1plus1, 0, pt2Min, pt1Min, multBinBegin, multBinEnd, kFALSE, step_1plus1_mixed, &trigger_mixed_comb);
+    else //this is never used, it's the old method of getting the background    
+    */
+    h2_etaPhi_mixedComb = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_mixedComb, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kFALSE, step_mixed, &trigger_mixed_comb);
 
     h2_etaPhi_backgroundSame = (TH2D*) h->GetData()->GetSumOfRatios2(h->GetData(), step_backgroundSame, 0, pt1Min, pt1Max, multBinBegin, multBinEnd, kFALSE, step_mixed, &trigger_background_same);
 
@@ -617,6 +858,9 @@ TH1D* getAnalysis(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.
        h2_etaPhi_mixedComb->Scale(1.0/trigger_mixed_comb);
     }
     
+    if(trigger!=NULL)
+      *trigger = (Int_t)trigger_same-trigger_mixed_comb;
+
   }else{
     Printf("cannot subtract mixed combinatorics from step %i ", step);
     return 0;
@@ -678,11 +922,13 @@ TH1D* projectToTH1D(TH2D* etaPhi, char* name, int firstbin, int lastbin, int tri
   h1_phi_1->SetStats(kFALSE);
   h1_phi_1->Scale(1.0/trigger);
   h1_phi_1->Scale(1.0/(double)(lastbin-firstbin+1));
+  h1_phi_1->Scale(etaPhi->GetYaxis()->GetBinWidth(firstbin));//scale with eta bin width 
   h1_phi_1->GetXaxis()->SetRangeUser(-TMath::Pi()/2+0.01, TMath::Pi()/2-0.01);
   //h1_phi_1->GetXaxis()->SetRangeUser(-TMath::Pi()/2+0.01, 3*TMath::Pi()/2-0.01);
   h1_phi_1->SetYTitle("1/N \\ dN/(d \\Delta \\varphi)");
 
-  //symmetrize(h1_phi_1);
+  symmetrize(h1_phi_1);
+  subtractBaseline(h1_phi_1);
 
   return h1_phi_1;
 }
@@ -697,6 +943,84 @@ TLegend* getLegend(){
   return leg;
 }
 
+void compareAllBackground(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Double_t pt2Min = 2.0, Int_t subtractMixedComb = 0, Int_t subtractFlow = 0){
+
+  static const int pt_assoc_bins_number = 8;
+  Double_t pt_assoc_bins[pt_assoc_bins_number] = {0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 10.0};
+
+  for(int i=0; i<pt_assoc_bins_number-1; i++){
+    compareBackground(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 1, 5,  i, 0, subtractMixedComb, subtractFlow);
+    compareBackground(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 9, 10,  i, 1, subtractMixedComb, subtractFlow);
+  }
+
+}
+
+
+//compares the background of the mixed comb analysis with the 1+1 background
+void compareBackground(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Double_t pt2Min = 2.0, Double_t ptAssocMin = 0.5, Double_t ptAssocMax = 8.0, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t posX = 1, Int_t posY = 1, Int_t subtractMixedComb = 0, Int_t subtractFlow = 0){
+
+  Int_t trigger_mixed_comb=0;
+  Int_t trigger_1plus1=0;
+
+  TH1D* mixedComb = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, ptAssocMin, ptAssocMax, 6.9, multBinBegin, multBinEnd, 5, 1, 1, 0, subtractMixedComb, subtractFlow, &trigger_mixed_comb)->Clone();
+
+  //near side
+  //TH1D* onePlusOne = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, ptAssocMin, ptAssocMax, 6.9, multBinBegin, multBinEnd, 6, 1, 1, 0, subtractMixedComb, subtractFlow, &trigger_1plus1)->Clone();
+  //away side
+  TH1D* onePlusOne = (TH1*)getAnalysis(fileName, pt2Min, pt1Min, pt2Min, ptAssocMin, ptAssocMax, 6.9, multBinBegin, multBinEnd, 6, 1, 1, 0, subtractMixedComb, subtractFlow, &trigger_1plus1)->Clone();
+
+  onePlusOne->SetLineColor(kRed);
+
+  Printf("found trigger: mixed comb %i, 1plus1 %i", trigger_mixed_comb, trigger_1plus1);
+  //do not need to scale these distributions because both are already divided by the number of triggers
+
+  TCanvas* can = new TCanvas(Form("compare background, %i, %i ", posX, posY), Form("compare background, %i, %i ", posX, posY), posX*gBasisSize+100, posY*gBasisSize+50, gBasisSize, gBasisSize);
+
+  ((TH1*)(mixedComb->Clone()))->DrawCopy();
+  ((TH1*)(onePlusOne->Clone()))->DrawCopy("same");
+
+  TLegend *leg  = getLegend();
+  leg->AddEntry(mixedComb, "mixed combinatorics","l");
+  leg->AddEntry(onePlusOne, "1plus1 background","l");
+  leg->Draw("same");
+}
+
+void compareAllMixedComb(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Double_t pt2Min = 2.0, Int_t subtractMixedComb = 0, Int_t subtractFlow = 0){
+
+  static const int pt_assoc_bins_number = 8;
+  Double_t pt_assoc_bins[pt_assoc_bins_number] = {0.5, 1.0, 2.0, 3.0, 4.0, 6.0, 8.0, 10.0};
+
+  for(int i=0; i<pt_assoc_bins_number-1; i++){
+    compareMixedComb_sides(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 1, 5,  i, 0, subtractMixedComb, subtractFlow);
+    compareMixedComb_sides(fileName, pt1Min, pt1Max, pt2Min, pt_assoc_bins[i], pt_assoc_bins[i+1], 9, 10,  i, 1, subtractMixedComb, subtractFlow);
+  }
+
+}
+
+
+void compareMixedComb_sides(const char* fileName, double pt1Min = 4.0, double pt1Max = 14.0, Double_t pt2Min = 2.0, Double_t ptAssocMin = 0.5, Double_t ptAssocMax = 8.0, Int_t multBinBegin = 1, Int_t multBinEnd = 5, Int_t posX = 1, Int_t posY = 1, Int_t subtractMixedComb = 0, Int_t subtractFlow = 0){
+
+  Int_t trigger_mixed_comb=0;
+
+  TH1D* mixedComb_near = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, ptAssocMin, ptAssocMax, 6.9, multBinBegin, multBinEnd, 4, 1, 1, 0, subtractMixedComb, subtractFlow, &trigger_mixed_comb)->Clone();
+
+  TH1D* mixedComb_away = (TH1*)getAnalysis(fileName, pt1Min, pt1Max, pt2Min, ptAssocMin, ptAssocMax, 6.9, multBinBegin, multBinEnd, 5, 1, 1, 0, subtractMixedComb, subtractFlow, &trigger_mixed_comb)->Clone();
+
+ TCanvas* can = new TCanvas(Form("compare mixedComb, %i, %i ", posX, posY), Form("compare mixedComb, %i, %i ", posX, posY), posX*gBasisSize+100, posY*gBasisSize+50, gBasisSize, gBasisSize);
+
+ mixedComb_away->SetLineColor(kRed);
+
+  ((TH1*)(mixedComb_near->Clone()))->DrawCopy();
+  ((TH1*)(mixedComb_away->Clone()))->DrawCopy("same");
+
+  TLegend *leg  = getLegend();
+  leg->AddEntry(mixedComb_near, "near side","l");
+  leg->AddEntry(mixedComb_away, "away side","l");
+  //leg->Draw("same");
+}
+
+
+
 
 //calculates the mixed comb by scaling it up to the amount of trigger in same background
 //this method can probably not be used because the statistics is too smal
@@ -925,10 +1249,10 @@ void showResult(TH2* h2_etaPhi, Int_t posX, Int_t posY, Int_t alpha_bins, Double
   double signal2 = sum - background;
   double signal2_err = TMath::Sqrt(sum_err*sum_err+background_err*background_err);
 
-  //Double_t significance = signal2/h1_phi->GetBinError((bin_1+bin_2)/2);
-  //Double_t significance_err = signal2_err/(TMath::Sqrt(sum));
-  Double_t significance = signal2/(TMath::Sqrt(sum));
-  Double_t significance_err = TMath::Sqrt(TMath::Power(signal2_err/(TMath::Sqrt(sum)), 2) + TMath::Power(signal2/(TMath::Sqrt(sum*sum*sum)*sum_err), 2));
+  Double_t significance = signal2/h1_phi->GetBinError((bin_1+bin_2)/2);
+  Double_t significance_err = signal2_err/(TMath::Sqrt(sum));
+  //Double_t significance = signal2/(TMath::Sqrt(sum));
+  //Double_t significance_err = TMath::Sqrt(TMath::Power(signal2_err/(TMath::Sqrt(sum)), 2) + TMath::Power(signal2/(TMath::Sqrt(sum*sum*sum)*sum_err), 2));
 
   Double_t significance_rel = signal2/background;//signal over background
   Double_t significance_rel_err = TMath::Sqrt(TMath::Power(signal2_err/background,2)+TMath::Power(signal2/(background*background)*background_err,2));//signal over background
@@ -1394,3 +1718,24 @@ void test(const char* fileName, double pt1Min, double pt1Max, double pt2Min, dou
  TCanvas* c1 = new TCanvas("can1", "can1", 1200, 800);
  h2_etaPhi_mixedComb->DrawCopy("surf1");
 }
+
+void showAsymmetry(const char* fileName){
+  loadlibs();
+
+  TFile::Open(fileName);
+  AliTwoPlusOneContainer* h = (AliTwoPlusOneContainer*) GetTwoPlusOne(fileName);
+
+  TCanvas* c1 = new TCanvas("can1", "can1", 1200, 800);
+  h->GetAsymmetry()->DrawCopy();
+}
+
+void showTriggerPt(const char* fileName){
+  loadlibs();
+
+  TFile::Open(fileName);
+  AliTwoPlusOneContainer* h = (AliTwoPlusOneContainer*) GetTwoPlusOne(fileName);
+
+  TCanvas* c1 = new TCanvas("can1", "can1", 1200, 800);
+  h->GetTriggerPt()->DrawCopy("colz");
+}
+