coding conventions
authorjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Jun 2006 17:49:34 +0000 (17:49 +0000)
committerjgrosseo <jgrosseo@f7af4fe6-9843-0410-8265-dc069ae4e863>
Wed, 7 Jun 2006 17:49:34 +0000 (17:49 +0000)
PWG0/dNdEta/dNdEtaAnalysis.cxx
PWG0/dNdEta/dNdEtaAnalysis.h

index 761d2192020855e5bcd9ca87ac64e6186f5e720a..55a6e3cc7ffffb378623c99d3ccc229c3021d580 100644 (file)
@@ -21,73 +21,80 @@ ClassImp(dNdEtaAnalysis)
 dNdEtaAnalysis::dNdEtaAnalysis(Char_t* name, Char_t* title) :
 TNamed(name, title)
 {
-  hEtaVsVtx  = new TH2F(Form("%s_eta_vs_vtx", name),"",80,-20,20,120,-6,6);
-  hEtaVsVtx->SetXTitle("vtx z [cm]");
-  hEtaVsVtx->SetYTitle("#eta");
+  // constructor
 
-  hEtaVsVtxUncorrected = dynamic_cast<TH2F*> (hEtaVsVtx->Clone(Form("%s_eta_vs_vtx_uncorrected", name)));
-  hVtx       = hEtaVsVtx->ProjectionX(Form("%s_vtx", name));
+  fEtaVsVtx  = new TH2F(Form("%s_eta_vs_vtx", name),"",80,-20,20,120,-6,6);
+  fEtaVsVtx->SetXTitle("vtx z [cm]");
+  fEtaVsVtx->SetYTitle("#eta");
+
+  fEtaVsVtxUncorrected = dynamic_cast<TH2F*> (fEtaVsVtx->Clone(Form("%s_eta_vs_vtx_uncorrected", name)));
+  fVtx       = fEtaVsVtx->ProjectionX(Form("%s_vtx", name));
   for (Int_t i=0; i<kVertexBinning; ++i)
   {
-    hdNdEta[i]    = hEtaVsVtx->ProjectionY(Form("%s_dNdEta_%d", name, i));
-    hdNdEta[i]->SetYTitle("dN/d#eta");
+    fdNdEta[i]    = fEtaVsVtx->ProjectionY(Form("%s_dNdEta_%d", name, i));
+    fdNdEta[i]->SetYTitle("dN/d#eta");
   }
 
-  hEtaVsVtx->Sumw2();
-  hVtx->Sumw2();
+  fEtaVsVtx->Sumw2();
+  fVtx->Sumw2();
 }
 
 //____________________________________________________________________
-void
-dNdEtaAnalysis::FillTrack(Float_t vtx, Float_t eta) {
-  hEtaVsVtxUncorrected->Fill(vtx,eta);
+void dNdEtaAnalysis::FillTrack(Float_t vtx, Float_t eta)
+{
+  // fills a track into the histograms
+
+  fEtaVsVtxUncorrected->Fill(vtx,eta);
 }
 
 //____________________________________________________________________
-void
-dNdEtaAnalysis::FillEvent(Float_t vtx) {
-  hVtx->Fill(vtx);
+void dNdEtaAnalysis::FillEvent(Float_t vtx)
+{
+  // fills an event into the histograms
+
+  fVtx->Fill(vtx);
 }
 
 //____________________________________________________________________
 void dNdEtaAnalysis::Finish(dNdEtaCorrection* correction)
 {
   // correct with correction values if available
+
   // TODO what do we do with the error?
   if (!correction)
     printf("INFO: No correction applied\n");
 
   // this can be replaced by TH2F::Divide if we agree that the binning will be always the same
-  for (Int_t iVtx=0; iVtx<=hEtaVsVtxUncorrected->GetNbinsX(); iVtx++)
+  for (Int_t iVtx=0; iVtx<=fEtaVsVtxUncorrected->GetNbinsX(); iVtx++)
   {
-    for (Int_t iEta=0; iEta<=hEtaVsVtxUncorrected->GetNbinsY(); iEta++)
+    for (Int_t iEta=0; iEta<=fEtaVsVtxUncorrected->GetNbinsY(); iEta++)
     {
       Float_t correctionValue = 1;
       if (correction)
-        correctionValue = correction->GetCorrection(hEtaVsVtxUncorrected->GetXaxis()->GetBinCenter(iVtx), hEtaVsVtxUncorrected->GetYaxis()->GetBinCenter(iEta));
+        correctionValue = correction->GetCorrection(fEtaVsVtxUncorrected->GetXaxis()->GetBinCenter(iVtx), fEtaVsVtxUncorrected->GetYaxis()->GetBinCenter(iEta));
 
-      Float_t value = hEtaVsVtxUncorrected->GetBinContent(iVtx, iEta);
-      Float_t error = hEtaVsVtxUncorrected->GetBinError(iVtx, iEta);
+      Float_t value = fEtaVsVtxUncorrected->GetBinContent(iVtx, iEta);
+      Float_t error = fEtaVsVtxUncorrected->GetBinError(iVtx, iEta);
 
       Float_t correctedValue = value * correctionValue;
       Float_t correctedError = error * correctionValue;
 
       if (correctedValue != 0)
       {
-        hEtaVsVtx->SetBinContent(iVtx, iEta, correctedValue);
-        hEtaVsVtx->SetBinError(iVtx, iEta, correctedError);
+        fEtaVsVtx->SetBinContent(iVtx, iEta, correctedValue);
+        fEtaVsVtx->SetBinError(iVtx, iEta, correctedError);
       }
     }
   }
 
-  for (Int_t iEta=0; iEta<=hEtaVsVtx->GetNbinsY(); iEta++)
+  for (Int_t iEta=0; iEta<=fEtaVsVtx->GetNbinsY(); iEta++)
   {
     // do we have several histograms for different vertex positions?
-    Int_t vertexBinWidth = hVtx->GetNbinsX() / (kVertexBinning-1);
+    Int_t vertexBinWidth = fVtx->GetNbinsX() / (kVertexBinning-1);
     for (Int_t vertexPos=0; vertexPos<kVertexBinning; ++vertexPos)
     {
       Int_t vertexBinBegin = 1;
-      Int_t vertexBinEnd = hVtx->GetNbinsX() + 1;
+      Int_t vertexBinEnd = fVtx->GetNbinsX() + 1;
 
       // the first histogram is always for the whole vertex range
       if (vertexPos > 0)
@@ -96,7 +103,7 @@ void dNdEtaAnalysis::Finish(dNdEtaCorrection* correction)
         vertexBinEnd = vertexBinBegin + vertexBinWidth;
       }
 
-      Float_t totalEvents = hVtx->Integral(vertexBinBegin, vertexBinEnd - 1);
+      Float_t totalEvents = fVtx->Integral(vertexBinBegin, vertexBinEnd - 1);
       if (totalEvents == 0)
       {
         printf("WARNING: No events for hist %d %d %d\n", vertexPos, vertexBinBegin, vertexBinEnd);
@@ -107,52 +114,55 @@ void dNdEtaAnalysis::Finish(dNdEtaCorrection* correction)
       Float_t sumError2 = 0;
       for (Int_t iVtx = vertexBinBegin; iVtx < vertexBinEnd; iVtx++)
       {
-        if (hEtaVsVtx->GetBinContent(iVtx, iEta) != 0)
+        if (fEtaVsVtx->GetBinContent(iVtx, iEta) != 0)
         {
-          sum = sum + hEtaVsVtx->GetBinContent(iVtx, iEta);
-          sumError2 = sumError2 + TMath::Power(hEtaVsVtx->GetBinError(iVtx, iEta),2);
+          sum = sum + fEtaVsVtx->GetBinContent(iVtx, iEta);
+          sumError2 = sumError2 + TMath::Power(fEtaVsVtx->GetBinError(iVtx, iEta),2);
         }
       }
 
       Float_t dndeta = sum / totalEvents;
       Float_t error  = TMath::Sqrt(sumError2) / totalEvents;
 
-      dndeta = dndeta/hdNdEta[vertexPos]->GetBinWidth(iEta);
-      error  = error/hdNdEta[vertexPos]->GetBinWidth(iEta);
+      dndeta = dndeta/fdNdEta[vertexPos]->GetBinWidth(iEta);
+      error  = error/fdNdEta[vertexPos]->GetBinWidth(iEta);
 
-      hdNdEta[vertexPos]->SetBinContent(iEta, dndeta);
-      hdNdEta[vertexPos]->SetBinError(iEta, error);
+      fdNdEta[vertexPos]->SetBinContent(iEta, dndeta);
+      fdNdEta[vertexPos]->SetBinError(iEta, error);
     }
   }
 }
 
 //____________________________________________________________________
-void
-dNdEtaAnalysis::SaveHistograms() {
+void dNdEtaAnalysis::SaveHistograms()
+{
+  // save the histograms to a directory with the name of this class (retrieved from TNamed)
 
   gDirectory->mkdir(GetName());
   gDirectory->cd(GetName());
 
-  hEtaVsVtx  ->Write();
-  hEtaVsVtxUncorrected->Write();
-  hVtx       ->Write();
+  fEtaVsVtx  ->Write();
+  fEtaVsVtxUncorrected->Write();
+  fVtx       ->Write();
   for (Int_t i=0; i<kVertexBinning; ++i)
-    hdNdEta[i]    ->Write();
+    fdNdEta[i]    ->Write();
 
   gDirectory->cd("../");
 }
 
 void dNdEtaAnalysis::LoadHistograms()
 {
+  // loads the histograms from a directory with the name of this class (retrieved from TNamed)
+
   gDirectory->cd(GetName());
 
-  hEtaVsVtx = dynamic_cast<TH2F*> (gDirectory->Get(hEtaVsVtx->GetName()));
-  hEtaVsVtxUncorrected = dynamic_cast<TH2F*> (gDirectory->Get(hEtaVsVtxUncorrected->GetName()));
+  fEtaVsVtx = dynamic_cast<TH2F*> (gDirectory->Get(fEtaVsVtx->GetName()));
+  fEtaVsVtxUncorrected = dynamic_cast<TH2F*> (gDirectory->Get(fEtaVsVtxUncorrected->GetName()));
 
-  hVtx = dynamic_cast<TH1D*> (gDirectory->Get(hVtx->GetName()));
+  fVtx = dynamic_cast<TH1D*> (gDirectory->Get(fVtx->GetName()));
 
   for (Int_t i=0; i<kVertexBinning; ++i)
-    hdNdEta[i] = dynamic_cast<TH1D*> (gDirectory->Get(hdNdEta[i]->GetName()));
+    fdNdEta[i] = dynamic_cast<TH1D*> (gDirectory->Get(fdNdEta[i]->GetName()));
 
   gDirectory->cd("../");
 }
@@ -160,24 +170,26 @@ void dNdEtaAnalysis::LoadHistograms()
 //____________________________________________________________________
 void dNdEtaAnalysis::DrawHistograms()
 {
+  // draws the histograms
+
   TCanvas* canvas = new TCanvas("dNdEtaAnalysis", "dNdEtaAnalysis", 800, 800);
   canvas->Divide(2, 2);
 
   canvas->cd(1);
-  if (hEtaVsVtx)
-    hEtaVsVtx->Draw("COLZ");
+  if (fEtaVsVtx)
+    fEtaVsVtx->Draw("COLZ");
 
   canvas->cd(2);
-  if (hEtaVsVtxUncorrected)
-    hEtaVsVtxUncorrected->Draw("COLZ");
+  if (fEtaVsVtxUncorrected)
+    fEtaVsVtxUncorrected->Draw("COLZ");
 
   canvas->cd(3);
-  if (hVtx)
-    hVtx->Draw();
+  if (fVtx)
+    fVtx->Draw();
 
   canvas->cd(4);
-  if (hdNdEta[0])
-    hdNdEta[0]->Draw();
+  if (fdNdEta[0])
+    fdNdEta[0]->Draw();
 
     // histograms for different vertices?
   if (kVertexBinning > 0)
@@ -194,11 +206,11 @@ void dNdEtaAnalysis::DrawHistograms()
     {
       //canvas2->cd(i-1);
       //printf("%d\n", i);
-      if (hdNdEta[i])
+      if (fdNdEta[i])
       {
-        hdNdEta[i]->SetLineColor(i+1);
-        hdNdEta[i]->Draw((i == 0) ? "" : "SAME");
-        legend->AddEntry(hdNdEta[i], (i == 0) ? "Vtx All" : Form("Vtx Bin %d", i-1));
+        fdNdEta[i]->SetLineColor(i+1);
+        fdNdEta[i]->Draw((i == 0) ? "" : "SAME");
+        legend->AddEntry(fdNdEta[i], (i == 0) ? "Vtx All" : Form("Vtx Bin %d", i-1));
       }
     }
 
@@ -234,21 +246,21 @@ Long64_t dNdEtaAnalysis::Merge(TCollection* list)
     if (entry == 0)
       continue;
 
-    collections[0]->Add(entry->hEtaVsVtx);
-    collections[1]->Add(entry->hEtaVsVtxUncorrected);
-    collections[2]->Add(entry->hVtx);
+    collections[0]->Add(entry->fEtaVsVtx);
+    collections[1]->Add(entry->fEtaVsVtxUncorrected);
+    collections[2]->Add(entry->fVtx);
 
     for (Int_t i=0; i<kVertexBinning; ++i)
-      collections[3+i]->Add(entry->hdNdEta[i]);
+      collections[3+i]->Add(entry->fdNdEta[i]);
 
     ++count;
   }
 
-  hEtaVsVtx->Merge(collections[0]);
-  hEtaVsVtxUncorrected->Merge(collections[1]);
-  hVtx->Merge(collections[2]);
+  fEtaVsVtx->Merge(collections[0]);
+  fEtaVsVtxUncorrected->Merge(collections[1]);
+  fVtx->Merge(collections[2]);
   for (Int_t i=0; i<kVertexBinning; ++i)
-    hdNdEta[i]->Merge(collections[3+i]);
+    fdNdEta[i]->Merge(collections[3+i]);
 
   for (Int_t i=0; i<nCollections; ++i)
     delete collections[i];
index 61d623c02ce9e0b1247f776a50dfd25613f1349e..575f972ce0756a4153afea91f1c1fbaf9192660f 100644 (file)
@@ -43,18 +43,18 @@ public:
 
   virtual Long64_t Merge(TCollection* list);
 
-  TH2F* GetEtaVsVtxHistogram() { return hEtaVsVtx; }
-  TH2F* GetEtaVsVtxUncorrectedHistogram() { return hEtaVsVtxUncorrected; }
-  TH1D* GetVtxHistogram() { return hVtx; }
-  TH1D* GetdNdEtaHistogram(Int_t i = 0) { return hdNdEta[i]; }
+  TH2F* GetEtaVsVtxHistogram() { return fEtaVsVtx; }
+  TH2F* GetEtaVsVtxUncorrectedHistogram() { return fEtaVsVtxUncorrected; }
+  TH1D* GetVtxHistogram() { return fVtx; }
+  TH1D* GetdNdEtaHistogram(Int_t i = 0) { return fdNdEta[i]; }
 
 protected:
-  TH2F* hEtaVsVtx;
-  TH2F* hEtaVsVtxUncorrected;
-  TH1D* hVtx;
-  TH1D* hdNdEta[kVertexBinning];
+  TH2F* fEtaVsVtx;              // histogram Eta vs vtx (track count)
+  TH2F* fEtaVsVtxUncorrected;   // uncorrected histograms Eta vs vtx (track count)
+  TH1D* fVtx;                   // vtx histogram (event count)
+  TH1D* fdNdEta[kVertexBinning];// dndeta results for different vertex bins (0 = full range)
 
-  ClassDef(dNdEtaAnalysis,0)
+  ClassDef(dNdEtaAnalysis, 0)
 };
 
 #endif