Fix coding violations
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 4 Mar 2011 15:41:00 +0000 (15:41 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 4 Mar 2011 15:41:00 +0000 (15:41 +0000)
39 files changed:
PWG2/FORWARD/analysis2/AliBasedNdetaTask.cxx
PWG2/FORWARD/analysis2/AliBasedNdetaTask.h
PWG2/FORWARD/analysis2/AliCentralMultiplicityTask.cxx
PWG2/FORWARD/analysis2/AliCentralMultiplicityTask.h
PWG2/FORWARD/analysis2/AliCentraldNdetaTask.cxx
PWG2/FORWARD/analysis2/AliCentraldNdetaTask.h
PWG2/FORWARD/analysis2/AliFMDCorrELossFit.cxx
PWG2/FORWARD/analysis2/AliFMDCorrELossFit.h
PWG2/FORWARD/analysis2/AliFMDCorrector.cxx
PWG2/FORWARD/analysis2/AliFMDCorrector.h
PWG2/FORWARD/analysis2/AliFMDDensityCalculator.cxx
PWG2/FORWARD/analysis2/AliFMDDensityCalculator.h
PWG2/FORWARD/analysis2/AliFMDEnergyFitter.cxx
PWG2/FORWARD/analysis2/AliFMDEnergyFitter.h
PWG2/FORWARD/analysis2/AliFMDEnergyFitterTask.h
PWG2/FORWARD/analysis2/AliFMDEventInspector.cxx
PWG2/FORWARD/analysis2/AliFMDEventInspector.h
PWG2/FORWARD/analysis2/AliFMDMCCorrector.cxx
PWG2/FORWARD/analysis2/AliFMDMCSharingFilter.cxx
PWG2/FORWARD/analysis2/AliFMDMCSharingFilter.h
PWG2/FORWARD/analysis2/AliFMDSharingFilter.cxx
PWG2/FORWARD/analysis2/AliFMDSharingFilter.h
PWG2/FORWARD/analysis2/AliForwardCorrectionManager.cxx
PWG2/FORWARD/analysis2/AliForwardCorrectionManager.h
PWG2/FORWARD/analysis2/AliForwardMCCorrectionsTask.cxx
PWG2/FORWARD/analysis2/AliForwardMCCorrectionsTask.h
PWG2/FORWARD/analysis2/AliForwardMultiplicityBase.cxx
PWG2/FORWARD/analysis2/AliForwardMultiplicityBase.h
PWG2/FORWARD/analysis2/AliForwardUtil.cxx
PWG2/FORWARD/analysis2/AliForwardUtil.h
PWG2/FORWARD/analysis2/AliForwarddNdetaTask.cxx
PWG2/FORWARD/analysis2/AliForwarddNdetaTask.h
PWG2/FORWARD/analysis2/older/AliFMDHistCollector.cxx [deleted file]
PWG2/FORWARD/analysis2/older/AliFMDHistCollector.h [deleted file]
PWG2/FORWARD/analysis2/older/DrawRes1D.C [deleted file]
PWG2/FORWARD/analysis2/older/DrawRes2D.C [deleted file]
PWG2/FORWARD/analysis2/older/DrawResBase.h [deleted file]
PWG2/FORWARD/analysis2/older/DrawResKeep.C [deleted file]
PWG2/FORWARD/analysis2/older/DrawResVtx.C [deleted file]

index 1091cc2..239580b 100644 (file)
@@ -30,7 +30,11 @@ AliBasedNdetaTask::AliBasedNdetaTask()
     fCorrEmpty(true), 
     fTriggerEff(1),
     fShapeCorr(0)
-{}
+{
+  // 
+  // Constructor
+  // 
+}
 
 //____________________________________________________________________
 AliBasedNdetaTask::AliBasedNdetaTask(const char* name)
@@ -50,6 +54,10 @@ AliBasedNdetaTask::AliBasedNdetaTask(const char* name)
     fTriggerEff(1),
     fShapeCorr(0)
 {
+  // 
+  // Constructor
+  // 
+
   // Output slot #1 writes into a TH1 container
   DefineOutput(1, TList::Class()); 
   DefineOutput(2, TList::Class()); 
@@ -77,6 +85,9 @@ AliBasedNdetaTask::AliBasedNdetaTask(const AliBasedNdetaTask& o)
 //____________________________________________________________________
 AliBasedNdetaTask::~AliBasedNdetaTask()
 {
+  // 
+  // Destructor
+  // 
   if (fSums) { 
     fSums->Delete();
     delete fSums;
@@ -93,6 +104,12 @@ AliBasedNdetaTask::~AliBasedNdetaTask()
 void 
 AliBasedNdetaTask::SetTriggerMask(const char* mask)
 {
+  // 
+  // Set the trigger maskl 
+  // 
+  // Parameters:
+  //    mask Trigger mask
+  //
   UShort_t    trgMask = 0;
   TString     trgs(mask);
   trgs.ToUpper();
@@ -115,6 +132,13 @@ AliBasedNdetaTask::SetTriggerMask(const char* mask)
 void 
 AliBasedNdetaTask::SetShapeCorrection(const TH1* c)
 {
+  // 
+  // Set the shape correction (a.k.a., track correction) for selected
+  // trigger(s)
+  // 
+  // Parameters:
+  //    h Correction
+  //
   if (!c) return;
   fShapeCorr = static_cast<TH1*>(c->Clone());
   fShapeCorr->SetDirectory(0);
@@ -124,9 +148,11 @@ AliBasedNdetaTask::SetShapeCorrection(const TH1* c)
 void 
 AliBasedNdetaTask::UserCreateOutputObjects()
 {
-  // Create histograms
-  // Called once (on the worker node)
-
+  // 
+  // Create output objects.  
+  //
+  // This is called once per slave process 
+  //
   fOutput = new TList;
   fOutput->SetName(Form("%s_result", GetName()));
   fOutput->SetOwner();
@@ -166,8 +192,18 @@ AliBasedNdetaTask::UserCreateOutputObjects()
 
 //____________________________________________________________________
 TH2D*
-AliBasedNdetaTask::CloneHist(TH2D* in, const char* name) 
+AliBasedNdetaTask::CloneHist(const TH2D* in, const char* name) 
 {
+  // 
+  // Clone a 2D histogram
+  // 
+  // Parameters:
+  //    in    Histogram to clone.
+  //    name  New name of clone.
+  // 
+  // Return:
+  //    The clone
+  //
   if (!in) return 0;
   TH2D* ret = static_cast<TH2D*>(in->Clone(name));
   ret->SetDirectory(0);
@@ -179,8 +215,17 @@ AliBasedNdetaTask::CloneHist(TH2D* in, const char* name)
 
 //____________________________________________________________________
 Bool_t
-AliBasedNdetaTask::CheckEvent(AliAODEvent* aod)
+AliBasedNdetaTask::CheckEvent(const AliAODEvent* aod)
 {
+  // 
+  // Check the trigger and vertex 
+  // 
+  // Parameters:
+  //    aod 
+  // 
+  // Return:
+  //    
+  //
   TObject*           oForward   = aod->FindListObject("Forward");
   if (!oForward) { 
     AliWarning("No forward object found");
@@ -223,6 +268,12 @@ AliBasedNdetaTask::CheckEvent(AliAODEvent* aod)
 void 
 AliBasedNdetaTask::UserExec(Option_t *) 
 {
+  // 
+  // Process a single event 
+  // 
+  // Parameters:
+  //    option Not used
+  //
   // Main loop
   AliAODEvent* aod = dynamic_cast<AliAODEvent*>(InputEvent());
   if (!aod) {
@@ -276,6 +327,16 @@ void
 AliBasedNdetaTask::SetHistogramAttributes(TH1D* h, Int_t colour, Int_t marker,
                                          const char* title, const char* ytitle)
 {
+  // 
+  // Set histogram graphical options, etc. 
+  // 
+  // Parameters:
+  //    h       Histogram to modify
+  //    colour  Marker color 
+  //    marker  Marker style
+  //    title   Title of histogram
+  //    ytitle  Title on y-axis. 
+  //
   h->SetTitle(title);
   h->SetMarkerColor(colour);
   h->SetMarkerStyle(marker);
@@ -301,6 +362,19 @@ AliBasedNdetaTask::ProjectX(const TH2D* h,
                            bool  corr,
                            bool  error) const
 {
+  // 
+  // Project onto the X axis 
+  // 
+  // Parameters:
+  //    h         2D histogram 
+  //    name      New name 
+  //    firstbin  First bin to use 
+  //    lastbin   Last bin to use
+  //    error     Whether to calculate errors
+  // 
+  // Return:
+  //    Newly created histogram or null
+  //
   if (!h) return 0;
   //#if USE_ROOT_PROJECT
   return h->ProjectionX(name, firstbin, lastbin, (error ? "e" : ""));
@@ -370,6 +444,14 @@ AliBasedNdetaTask::ProjectX(const TH2D* h,
 void 
 AliBasedNdetaTask::Terminate(Option_t *) 
 {
+  // 
+  // Called at end of event processing.. 
+  //
+  // This is called once in the master 
+  // 
+  // Parameters:
+  //    option Not used 
+  //
   // Draw result to screen, or perform fitting, normalizations Called
   // once at the end of the query
         
@@ -471,7 +553,7 @@ AliBasedNdetaTask::Terminate(Option_t *)
     
   
 
-  /*
+  //
   std::cout<<norm->GetMaximumBin()<<"    "<< (Float_t)nAccepted / norm->GetBinContent((Float_t)norm->GetMaximumBin()) <<std::endl;
   Float_t scaleForNorm =  (Float_t)nAccepted / (Float_t)norm->GetBinContent(norm->GetMaximumBin()) ;
   //Float_t scaleForNorm =  norm->Integral() ;
@@ -482,7 +564,7 @@ AliBasedNdetaTask::Terminate(Option_t *)
   //norm->Scale(norm->GetNbinsX() / (norm->GetXaxis()->GetXmax() - norm->GetXaxis()->GetXmin() ));
   
   //norm->Scale(1.,"width");
-  */
+  //
   // Project onto eta axis - _ignoring_underflow_bins_!
   
   TH2D* tmpNorm = (TH2D*)fSum->Clone("tmpNorm");
@@ -567,6 +649,15 @@ AliBasedNdetaTask::Terminate(Option_t *)
 TH1D*
 AliBasedNdetaTask::Rebin(const TH1D* h) const
 {
+  // 
+  // Make a copy of the input histogram and rebin that histogram
+  // 
+  // Parameters:
+  //    h  Histogram to rebin
+  // 
+  // Return:
+  //    New (rebinned) histogram
+  //
   if (fRebin <= 1) return 0;
 
   Int_t nBins = h->GetNbinsX();
@@ -623,16 +714,18 @@ AliBasedNdetaTask::Rebin(const TH1D* h) const
 }
 
 //__________________________________________________________________
-/** 
- * Make an extension of @a h to make it symmetric about 0 
- * 
- * @param h Histogram to symmertrice 
- * 
- * @return Symmetric extension of @a h 
- */
 TH1* 
 AliBasedNdetaTask::Symmetrice(const TH1* h) const
 {
+  // 
+  // Make an extension of @a h to make it symmetric about 0 
+  // 
+  // Parameters:
+  //    h Histogram to symmertrice 
+  // 
+  // Return:
+  //    Symmetric extension of @a h 
+  //
   Int_t nBins = h->GetNbinsX();
   TH1* s = static_cast<TH1*>(h->Clone(Form("%s_mirror", h->GetName())));
   s->SetTitle(Form("%s (mirrored)", h->GetTitle()));
@@ -666,3 +759,6 @@ AliBasedNdetaTask::Symmetrice(const TH1* h) const
   s->SetBinError(l2+1, h->GetBinError(first));
   return s;
 }
+//
+// EOF
+//
index c6ff44b..44cc8c6 100644 (file)
@@ -109,7 +109,7 @@ protected:
    * 
    * @return Retrieved histogram or null
    */
-  virtual TH2D* GetHistogram(AliAODEvent* aod, Bool_t mc=false) = 0;
+  virtual TH2D* GetHistogram(const AliAODEvent* aod, Bool_t mc=false) = 0;
   /** 
    * Check the trigger and vertex 
    * 
@@ -117,7 +117,7 @@ protected:
    * 
    * @return 
    */
-  Bool_t CheckEvent(AliAODEvent* aod);
+  Bool_t CheckEvent(const AliAODEvent* aod);
   /** 
    * Clone a 2D histogram
    * 
@@ -126,7 +126,7 @@ protected:
    * 
    * @return The clone
    */
-  TH2D* CloneHist(TH2D* in, const char* name);
+  TH2D* CloneHist(const TH2D* in, const char* name);
   /** 
    * Make a copy of the input histogram and rebin that histogram
    * 
index bf6ead9..f2d6df7 100644 (file)
@@ -37,9 +37,11 @@ AliCentralMultiplicityTask::AliCentralMultiplicityTask(const char* name)
     fAODCentral(kFALSE),
     fManager(),
     fUseSecondary(true),
-    firstEventSeen(false)
+    fFirstEventSeen(false)
 {
-  
+  // 
+  // Constructor 
+  //   
   DefineOutput(1, TList::Class());
 }
 //____________________________________________________________________
@@ -50,8 +52,11 @@ AliCentralMultiplicityTask::AliCentralMultiplicityTask()
     fAODCentral(),
     fManager(),
     fUseSecondary(true),
-    firstEventSeen(false)
+    fFirstEventSeen(false)
 {
+  // 
+  // Constructor 
+  // 
 }
 //____________________________________________________________________
 AliCentralMultiplicityTask::AliCentralMultiplicityTask(const AliCentralMultiplicityTask& o)
@@ -61,24 +66,34 @@ AliCentralMultiplicityTask::AliCentralMultiplicityTask(const AliCentralMultiplic
     fAODCentral(o.fAODCentral),
     fManager(o.fManager),
     fUseSecondary(o.fUseSecondary),
-    firstEventSeen(o.firstEventSeen)
+    fFirstEventSeen(o.fFirstEventSeen)
 {
+  //
+  // Copy constructor 
+  // 
 }
 //____________________________________________________________________
 AliCentralMultiplicityTask&
 AliCentralMultiplicityTask::operator=(const AliCentralMultiplicityTask& o)
 {
+  // 
+  // Assignment operator 
+  //
   fData          = o.fData;
   fList          = o.fList;
   fAODCentral    = o.fAODCentral;
   fManager       = o.fManager;
   fUseSecondary  = o.fUseSecondary;
-  firstEventSeen = o.firstEventSeen;
+  fFirstEventSeen = o.fFirstEventSeen;
   return *this;
 }
 //____________________________________________________________________
 void AliCentralMultiplicityTask::UserCreateOutputObjects() 
 {
+  // 
+  // Create output objects 
+  // 
+  //
 
   AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
   AliAODHandler*      ah = 
@@ -97,6 +112,12 @@ void AliCentralMultiplicityTask::UserCreateOutputObjects()
 //____________________________________________________________________
 void AliCentralMultiplicityTask::UserExec(Option_t* /*option*/) 
 {
+  // 
+  // Process each event 
+  // 
+  // Parameters:
+  //    option Not used
+  //  
   
   AliESDInputHandler* eventHandler = 
     dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()
@@ -107,7 +128,7 @@ void AliCentralMultiplicityTask::UserExec(Option_t* /*option*/)
   
   AliESDEvent* esd = eventHandler->GetEvent();
   
-  if(!GetManager().IsInit() && !firstEventSeen) {
+  if(!GetManager().IsInit() && !fFirstEventSeen) {
     AliFMDEventInspector inspector;
     inspector.ReadRunDetails(esd);
     GetManager().Init(inspector.GetCollisionSystem(),
@@ -116,7 +137,7 @@ void AliCentralMultiplicityTask::UserExec(Option_t* /*option*/)
     
     //std::cout<<inspector.GetCollisionSystem()<<"  "<<inspector.GetEnergy()<<"    "<<inspector.GetField()<<std::endl;
     AliInfo("Manager of corrections in AliCentralMultiplicityTask init");
-    firstEventSeen = kTRUE;
+    fFirstEventSeen = kTRUE;
   }
   
   //Selecting only events with |valid vertex| < 10 cm
@@ -195,11 +216,23 @@ void AliCentralMultiplicityTask::UserExec(Option_t* /*option*/)
 //____________________________________________________________________
 void AliCentralMultiplicityTask::Terminate(Option_t* /*option*/) 
 {
+  // 
+  // End of job
+  // 
+  // Parameters:
+  //    option Not used 
+  //
 }
 //____________________________________________________________________
 void
 AliCentralMultiplicityTask::Print(Option_t* /*option*/) const
 {
+  // 
+  // Print information 
+  // 
+  // Parameters:
+  //    option Not used
+  //
 }
 //====================================================================
 AliCentralMultiplicityTask::Manager::Manager() :
@@ -211,8 +244,9 @@ AliCentralMultiplicityTask::Manager::Manager() :
   fSecMapName("centralsecmap"),
   fIsInit(kFALSE)
 {
-
-
+  //
+  // Constructor 
+  // 
 }
 //____________________________________________________________________
 AliCentralMultiplicityTask::Manager::Manager(const Manager& o) 
@@ -223,11 +257,18 @@ AliCentralMultiplicityTask::Manager::Manager(const Manager& o)
    fAcceptanceName(o.fAcceptanceName),
    fSecMapName(o.fSecMapName),
    fIsInit(o.fIsInit)
-{}
+{
+  //
+  // Copy Constructor 
+  // 
+}
 //____________________________________________________________________
 AliCentralMultiplicityTask::Manager&
 AliCentralMultiplicityTask::Manager::operator=(const Manager& o)
 {
+  //
+  // Assignment operator  
+  // 
   fAcceptancePath = o.fAcceptancePath;
   fSecMapPath     = o.fSecMapPath;
   fAcceptance     = o.fAcceptance;
@@ -245,6 +286,18 @@ AliCentralMultiplicityTask::Manager::GetFullFileName(UShort_t what,
                                                     UShort_t sNN,  
                                                     Short_t  field) const
 {
+  // 
+  // Get full path name to object file 
+  // 
+  // Parameters:
+  //    what   What to get 
+  //    sys    Collision system
+  //    sNN    Center of mass energy 
+  //    field  Magnetic field 
+  // 
+  // Return:
+  //    
+  //
   return Form("%s/%s",
              what == 0 ? GetSecMapPath() : GetAcceptancePath(), 
              GetFileName(what, sys, sNN, field));
@@ -257,6 +310,18 @@ AliCentralMultiplicityTask::Manager::GetFileName(UShort_t  what ,
                                                 UShort_t  sNN,
                                                 Short_t   field) const
 {
+  // 
+  // Get the full path name 
+  // 
+  // Parameters:
+  //    what   What to get
+  //    sys    Collision system
+  //    sNN    Center of mass energy 
+  //    field  Magnetic field 
+  // 
+  // Return:
+  //    
+  //
   // Must be static - otherwise the data may disappear on return from
   // this member function
   static TString fname = "";
@@ -281,6 +346,15 @@ AliCentralMultiplicityTask::Manager::GetFileName(UShort_t  what ,
 TH2D* 
 AliCentralMultiplicityTask::Manager::GetSecMapCorrection(UShort_t vtxbin) const
 {
+  // 
+  // Get the secondary map
+  // 
+  // Parameters:
+  //    vtxbin 
+  // 
+  // Return:
+  //    
+  //
   if (!fSecmap) { 
     ::Warning("GetSecMapCorrection","No secondary map defined");
     return 0;
@@ -292,6 +366,15 @@ TH1D*
 AliCentralMultiplicityTask::Manager::GetAcceptanceCorrection(UShort_t vtxbin) 
   const 
 {
+  // 
+  // Get the acceptance correction 
+  // 
+  // Parameters:
+  //    vtxbin 
+  // 
+  // Return:
+  //    
+  //
   if (!fAcceptance) { 
     ::Warning("GetAcceptanceCorrection","No acceptance map defined");
     return 0;
@@ -305,6 +388,14 @@ AliCentralMultiplicityTask::Manager::Init(UShort_t  sys,
                                          UShort_t  sNN,
                                          Short_t   field) 
 {
+  // 
+  // Initialize 
+  // 
+  // Parameters:
+  //    sys    Collision system (1: pp, 2: PbPb)
+  //    sNN    Center of mass energy per nucleon pair [GeV]
+  //    field  Magnetic field [kG]
+  //
   if(fIsInit) ::Warning("Init","Already initialised - overriding...");
   
   TFile fsec(GetFullFileName(0,sys,sNN,field));
index 0019d2d..172d04c 100644 (file)
@@ -272,13 +272,13 @@ public:
 
 protected: 
   
-  TH2D*                  fData;          //sum histogram if needed
-  TList*                 fList;          //Output List for diagnostics
-  AliAODCentralMult      fAODCentral;    // Output object
-  Manager                fManager;       //Manager object for corrections
-  Bool_t                 fUseSecondary;  // Whether to secondary map
-  Bool_t                 firstEventSeen; // Have we seen first event     
-  ClassDef(AliCentralMultiplicityTask,1) // Forward multiplicity class
+  TH2D*                  fData;           //sum histogram if needed
+  TList*                 fList;           //Output List for diagnostics
+  AliAODCentralMult      fAODCentral;     // Output object
+  Manager                fManager;        //Manager object for corrections
+  Bool_t                 fUseSecondary;   // Whether to secondary map
+  Bool_t                 fFirstEventSeen; // Have we seen first event     
+  ClassDef(AliCentralMultiplicityTask,1)  // Forward multiplicity class
 };
 
 #endif
index 0a5d831..70c55a1 100644 (file)
@@ -16,7 +16,7 @@
 
 //____________________________________________________________________
 TH2D*
-AliCentraldNdetaTask::GetHistogram(AliAODEvent* aod, Bool_t mc) 
+AliCentraldNdetaTask::GetHistogram(const AliAODEvent* aod, Bool_t mc) 
 {
   // Get objects from the event structure 
   TObject* obj = 0;
index b1cf4f7..b3bb240 100644 (file)
@@ -45,7 +45,7 @@ protected:
    * 
    * @return 
    */
-  TH2D* GetHistogram(AliAODEvent* aod, Bool_t mc=false);
+  TH2D* GetHistogram(const AliAODEvent* aod, Bool_t mc=false);
 
   ClassDef(AliCentraldNdetaTask,1); // Determine multiplicity in central area
 };
index 777cfe8..e3f4218 100644 (file)
@@ -15,7 +15,7 @@
 #include <iostream>
 #include <iomanip>
 
-Double_t AliFMDCorrELossFit::ELossFit::fgMaxRelError = .2;
+Double_t AliFMDCorrELossFit::ELossFit::fgMaxRelError = .12;
 Double_t AliFMDCorrELossFit::ELossFit::fgLeastWeight = 1e-5;
 Double_t AliFMDCorrELossFit::ELossFit::fgMaxChi2nu   = 20;
 
@@ -96,7 +96,7 @@ AliFMDCorrELossFit::ELossFit::ELossFit(Int_t     quality,UShort_t  n,
                                       Double_t  xi,     Double_t  exi,
                                       Double_t  sigma,  Double_t  esigma, 
                                       Double_t  sigman, Double_t  esigman, 
-                                      Double_t* a,      Double_t* ea)
+                                      const Double_t* a,const Double_t* ea)
   : fN(n),
     fNu(nu),
     fChi2(chi2),
@@ -606,7 +606,8 @@ AliFMDCorrELossFit::FindEtaBin(Double_t eta) const
   //    Bin (in @f$[1,N_{bins}]@f$) corresponding to the given
   // eta, or 0 if out of range.
   //
-  if (fEtaAxis.GetXmin() == fEtaAxis.GetXmax() || fEtaAxis.GetNbins() == 0) {
+  if (TMath::Abs(fEtaAxis.GetXmin() - fEtaAxis.GetXmax()) < 1e-6 
+      || fEtaAxis.GetNbins() == 0) {
     AliWarning("No eta axis defined");
     return -1;
   }
@@ -1136,6 +1137,14 @@ AliFMDCorrELossFit::Draw(Option_t* option)
 void
 AliFMDCorrELossFit::Print(Option_t* option) const
 {
+  // 
+  // Print this object.  
+  // 
+  // Parameters:
+  //    option Options 
+  //   - R   Print recursive  
+  //
+  //
   TString opt(option);
   opt.ToUpper();
   Int_t nRings = fRings.GetEntriesFast();
index 4d8fca4..027afb8 100644 (file)
@@ -95,7 +95,7 @@ public:
             Double_t  xi,     Double_t  exi,
             Double_t  sigma,  Double_t  esigma, 
             Double_t  sigman, Double_t  esigman, 
-            Double_t* a,      Double_t* ea);
+            const Double_t* a,const Double_t* ea);
     /** 
      * Copy constructor 
      * 
index 0b7681c..6a7a81c 100644 (file)
@@ -8,6 +8,10 @@
 #include <TList.h>
 #include <TMath.h>
 #include "AliForwardCorrectionManager.h"
+// #include "AliFMDCorrDoubleHit.h"
+#include "AliFMDCorrVertexBias.h"
+#include "AliFMDCorrMergingEfficiency.h"
+#include "AliFMDCorrAcceptance.h"
 #include "AliLog.h"
 #include <TH2D.h>
 #include <TROOT.h>
@@ -245,7 +249,7 @@ AliFMDCorrector::Correct(AliForwardUtil::Histos& hists,
 
 //____________________________________________________________________
 void
-AliFMDCorrector::ScaleHistograms(TList* dir, Int_t nEvents)
+AliFMDCorrector::ScaleHistograms(const TList* dir, Int_t nEvents)
 {
   // 
   // Scale the histograms to the total number of events 
@@ -266,6 +270,12 @@ AliFMDCorrector::ScaleHistograms(TList* dir, Int_t nEvents)
 void
 AliFMDCorrector::DefineOutput(TList* dir)
 {
+  // 
+  // Output diagnostic histograms to directory 
+  // 
+  // Parameters:
+  //    dir List to write in
+  //  
   TList* d = new TList;
   d->SetName(GetName());
   dir->Add(d);
index 9df074d..bfa0784 100644 (file)
@@ -84,7 +84,7 @@ public:
    * @param dir     Where the output is stored
    * @param nEvents Number of events 
    */
-  virtual void ScaleHistograms(TList* dir, Int_t nEvents);
+  virtual void ScaleHistograms(const TList* dir, Int_t nEvents);
   /** 
    * Output diagnostic histograms to directory 
    * 
index 3f8f716..26b7b41 100644 (file)
@@ -7,6 +7,8 @@
 #include <TList.h>
 #include <TMath.h>
 #include "AliForwardCorrectionManager.h"
+#include "AliFMDCorrDoubleHit.h"
+#include "AliFMDCorrELossFit.h"
 #include "AliLog.h"
 #include <TH2D.h>
 #include <TProfile.h>
@@ -332,9 +334,18 @@ AliFMDDensityCalculator::Calculate(const AliESDFMD&        fmd,
 
 //_____________________________________________________________________
 Int_t
-AliFMDDensityCalculator::FindMaxWeight(AliFMDCorrELossFit* cor,
+AliFMDDensityCalculator::FindMaxWeight(const AliFMDCorrELossFit* cor,
                                       UShort_t d, Char_t r, Int_t iEta) const
 {
+  // 
+  // Find the max weight to use for FMD<i>dr</i> in eta bin @a iEta
+  // 
+  // Parameters:
+  //    cor   Correction
+  //    d     Detector 
+  //    r     Ring 
+  //    iEta  Eta bin 
+  //
   AliFMDCorrELossFit::ELossFit* fit = cor->GetFit(d,r,iEta);
   if (!fit) { 
     // AliWarning(Form("No energy loss fit for FMD%d%c at eta=%f", d, r, eta));
@@ -347,6 +358,9 @@ AliFMDDensityCalculator::FindMaxWeight(AliFMDCorrELossFit* cor,
 void
 AliFMDDensityCalculator::CacheMaxWeights()
 {
+  // 
+  // Find the max weights and cache them 
+  // 
   AliForwardCorrectionManager&  fcm = AliForwardCorrectionManager::Instance();
   AliFMDCorrELossFit*           cor = fcm.GetELossFit();
   const TAxis&                  eta = cor->GetEtaAxis();
@@ -371,6 +385,18 @@ AliFMDDensityCalculator::CacheMaxWeights()
 Int_t
 AliFMDDensityCalculator::GetMaxWeight(UShort_t d, Char_t r, Int_t iEta) const
 {
+  // 
+  // Find the (cached) maximum weight for FMD<i>dr</i> in 
+  // @f$\eta@f$ bin @a iEta
+  // 
+  // Parameters:
+  //    d     Detector
+  //    r     Ring
+  //    iEta  Eta bin
+  // 
+  // Return:
+  //    max weight or <= 0 in case of problems 
+  //
   if (iEta < 0) return -1;
 
   const TArrayI* max  = 0;
@@ -399,6 +425,18 @@ AliFMDDensityCalculator::GetMaxWeight(UShort_t d, Char_t r, Int_t iEta) const
 Int_t
 AliFMDDensityCalculator::GetMaxWeight(UShort_t d, Char_t r, Float_t eta) const
 {
+  // 
+  // Find the (cached) maximum weight for FMD<i>dr</i> iat
+  // @f$\eta@f$ 
+  // 
+  // Parameters:
+  //    d     Detector
+  //    r     Ring
+  //    eta   Eta bin
+  // 
+  // Return:
+  //    max weight or <= 0 in case of problems 
+  //
   AliForwardCorrectionManager&  fcm  = AliForwardCorrectionManager::Instance();
   Int_t                         iEta = fcm.GetELossFit()->FindEtaBin(eta) -1;
 
@@ -606,7 +644,7 @@ AliFMDDensityCalculator::AcceptanceCorrection(Char_t r, UShort_t t) const
 
 //____________________________________________________________________
 void
-AliFMDDensityCalculator::ScaleHistograms(TList* dir, Int_t nEvents)
+AliFMDDensityCalculator::ScaleHistograms(const TList* dir, Int_t nEvents)
 {
   // 
   // Scale the histograms to the total number of events 
index 108ff44..3d66880 100644 (file)
@@ -87,7 +87,7 @@ public:
    * @param dir     where to put the output
    * @param nEvents Number of events 
    */
-  virtual void ScaleHistograms(TList* dir, Int_t nEvents);
+  virtual void ScaleHistograms(const TList* dir, Int_t nEvents);
   /** 
    * Output diagnostic histograms to directory 
    * 
@@ -152,7 +152,7 @@ protected:
    * @param r     Ring 
    * @param iEta  Eta bin 
    */
-  Int_t FindMaxWeight(AliFMDCorrELossFit* cor,
+  Int_t FindMaxWeight(const AliFMDCorrELossFit* cor,
                      UShort_t d, Char_t r, Int_t iEta) const;
 
   /** 
index 395aa21..54e90b7 100644 (file)
@@ -1097,15 +1097,15 @@ AliFMDEnergyFitter::RingHistos::FitHist(TH1*     dist,
 
 
   // Now, we need to select the best fit 
-  Int_t nFits = f.fFitResults.GetEntriesFast();
+  Int_t nFits = f.GetFitResults().GetEntriesFast();
   TF1*  good[nFits];
   for (Int_t i = nFits-1; i >= 0; i--) { 
     good[i] = 0;
-    TF1* ff = static_cast<TF1*>(f.fFunctions.At(i));
+    TF1* ff = static_cast<TF1*>(f.GetFunctions().At(i));
     // ff->SetLineColor(Color());
     ff->SetRange(0, maxRange);
     dist->GetListOfFunctions()->Add(new TF1(*ff));
-    if (CheckResult(static_cast<TFitResult*>(f.fFitResults.At(i)),
+    if (CheckResult(static_cast<TFitResult*>(f.GetFitResults().At(i)),
                    relErrorCut, chi2nuCut)) {
       good[i] = ff;
       ff->SetLineWidth(2);
@@ -1113,20 +1113,20 @@ AliFMDEnergyFitter::RingHistos::FitHist(TH1*     dist,
     }
   }
   // If all else fails, use the 1 particle fit 
-  TF1* ret = static_cast<TF1*>(f.fFunctions.At(0));
+  TF1* ret = static_cast<TF1*>(f.GetFunctions().At(0));
 
   // Find the fit with the most valid particles 
   for (Int_t i = nFits-1; i > 0; i--) {
     if (!good[i]) continue;
     if (fDebug > 1) {
       AliInfo(Form("Choosing fit with n=%d", i+1));
-      f.fFitResults.At(i)->Print();
+      f.GetFitResults().At(i)->Print();
     }
     ret = good[i];
     break;
   }
   // Give a warning if we're using fall-back 
-  if (ret == f.fFunctions.At(0)) {
+  if (ret == f.GetFunctions().At(0)) {
     AliWarning("Choosing fall-back 1 particle fit");
   }
   // Copy our result and return (the functions are owned by the fitter)
@@ -1217,7 +1217,7 @@ AliFMDEnergyFitter::RingHistos::CheckResult(TFitResult* r,
 
 //__________________________________________________________________
 void
-AliFMDEnergyFitter::RingHistos::FindBestFits(TList*              d, 
+AliFMDEnergyFitter::RingHistos::FindBestFits(const TList*        d, 
                                             AliFMDCorrELossFit& obj,
                                             const TAxis&        eta,     
                                             Double_t            relErrorCut, 
@@ -1273,7 +1273,7 @@ AliFMDEnergyFitter::RingHistos::FindBestFits(TList*              d,
 
 //__________________________________________________________________
 AliFMDCorrELossFit::ELossFit* 
-AliFMDEnergyFitter::RingHistos::FindBestFit(TH1* dist,
+AliFMDEnergyFitter::RingHistos::FindBestFit(const TH1* dist,
                                            Double_t relErrorCut, 
                                            Double_t chi2nuCut,
                                            Double_t minWeightCut) 
index 82f6997..62a85a2 100644 (file)
@@ -368,7 +368,7 @@ protected:
      *                       the reduced @f$\chi^2@f$ 
      * @param minWeightCut   Least valid @f$ a_i@f$ 
      */
-    void FindBestFits(TList*              d, 
+    void FindBestFits(const TList*        d, 
                      AliFMDCorrELossFit& obj,
                      const TAxis&        eta,     
                      Double_t            relErrorCut, 
@@ -387,7 +387,7 @@ protected:
      * 
      * @return Best fit 
      */
-    AliFMDCorrELossFit::ELossFit* FindBestFit(TH1* dist,
+    AliFMDCorrELossFit::ELossFit* FindBestFit(const TH1* dist,
                                              Double_t relErrorCut, 
                                              Double_t chi2nuCut,
                                              Double_t minWeightCut);
index 0324582..4085577 100644 (file)
@@ -4,7 +4,6 @@
 #ifndef ALIFMDENERGYFITTERTASK_H
 #define ALIFMDENERGYFITTERTASK_H
 #include <AliAnalysisTaskSE.h>
-#include "AliForwardUtil.h"
 #include "AliFMDEventInspector.h"
 #include "AliFMDEnergyFitter.h"
 #include <AliESDFMD.h>
index 9f76c52..a51d8b5 100644 (file)
@@ -163,7 +163,7 @@ AliFMDEventInspector::operator=(const AliFMDEventInspector& o)
 
 //____________________________________________________________________
 Bool_t
-AliFMDEventInspector::FetchHistograms(TList* d, 
+AliFMDEventInspector::FetchHistograms(const TList* d, 
                                      TH1I*& hEventsTr, 
                                      TH1I*& hEventsTrVtx, 
                                      TH1I*& hTriggers) const
index 4c4b559..6cdb3aa 100644 (file)
@@ -170,7 +170,7 @@ public:
    * 
    * @return true on success, false otherwise 
    */
-  Bool_t FetchHistograms(TList* d, 
+  Bool_t FetchHistograms(const TList* d, 
                         TH1I*& hEventsTr, 
                         TH1I*& hEventsTrVtx, 
                         TH1I*& hTriggers) const;
@@ -238,7 +238,7 @@ protected:
   TList*   fList;         //! Histogram container 
   UShort_t fEnergy;       // CMS energy (per nucleon pair) [GeV]
   Short_t  fField;        // L3 magnetic field [kG]
-  UShort_t fCollisionSystem; //  
+  UShort_t fCollisionSystem; //  Collision system
   Int_t    fDebug;        //  Debug level 
   ClassDef(AliFMDEventInspector,2); // Inspect the event 
 };
index a4520e0..d56a10b 100644 (file)
@@ -21,6 +21,7 @@
 #include <TList.h>
 #include <TMath.h>
 #include "AliForwardCorrectionManager.h"
+#include "AliFMDCorrVertexBias.h"
 #include "AliLog.h"
 #include <TH2D.h>
 #include <TROOT.h>
index ddfc934..db3c03b 100644 (file)
@@ -339,7 +339,7 @@ AliFMDMCSharingFilter::DefineOutput(TList* dir)
 
 //____________________________________________________________________
 void
-AliFMDMCSharingFilter::ScaleHistograms(TList* dir, Int_t nEvents)
+AliFMDMCSharingFilter::ScaleHistograms(const TList* dir, Int_t nEvents)
 {
   // 
   // Scale the histograms to the total number of events 
index 589b645..0b3372e 100644 (file)
@@ -109,7 +109,7 @@ public:
    * @param dir     Where the output is 
    * @param nEvents Number of events 
    */
-  void ScaleHistograms(TList* dir, Int_t nEvents);
+  void ScaleHistograms(const TList* dir, Int_t nEvents);
   /** 
    * Print information
    * 
index 7266d6e..7f2b999 100644 (file)
@@ -28,6 +28,7 @@
 #include <TH1.h>
 #include <TMath.h>
 #include "AliForwardCorrectionManager.h"
+#include "AliFMDCorrELossFit.h"
 #include <AliLog.h>
 #include <TROOT.h>
 #include <iostream>
@@ -336,7 +337,7 @@ AliFMDSharingFilter::MultiplicityOfStrip(Double_t mult,
                                         UShort_t /*s*/,
                                         UShort_t /*t*/,
                                         Bool_t&  usedPrev, 
-                                        Bool_t&  usedThis) 
+                                        Bool_t&  usedThis) const
 {
   // 
   // The actual algorithm 
@@ -478,7 +479,7 @@ AliFMDSharingFilter::DeAngleCorrect(Double_t mult, Double_t eta) const
 
 //____________________________________________________________________
 void
-AliFMDSharingFilter::ScaleHistograms(TList* dir, Int_t nEvents)
+AliFMDSharingFilter::ScaleHistograms(const TList* dir, Int_t nEvents)
 {
   // 
   // Scale the histograms to the total number of events 
@@ -659,7 +660,8 @@ AliFMDSharingFilter::RingHistos::Finish()
 
 //____________________________________________________________________
 void
-AliFMDSharingFilter::RingHistos::ScaleHistograms(TList* dir, Int_t nEvents)
+AliFMDSharingFilter::RingHistos::ScaleHistograms(const TList* dir, 
+                                                Int_t nEvents)
 {
   // 
   // Scale the histograms to the total number of events 
index e7fa543..b954c20 100644 (file)
@@ -122,7 +122,7 @@ public:
    * @param dir     Where the output is 
    * @param nEvents Number of events 
    */
-  virtual void ScaleHistograms(TList* dir, Int_t nEvents);
+  virtual void ScaleHistograms(const TList* dir, Int_t nEvents);
   
   /** 
    * Define the output histograms.  These are put in a sub list of the
@@ -199,7 +199,7 @@ protected:
      * @param nEvents Number of events 
      * @param dir     Where the output is 
      */
-    void ScaleHistograms(TList* dir, Int_t nEvents);
+    void ScaleHistograms(const TList* dir, Int_t nEvents);
     TH1D*     fBefore;       // Distribution of signals before filter
     TH1D*     fAfter;        // Distribution of signals after filter
     TH1D*     fHits;         // Distribution of hit strips. 
@@ -258,7 +258,7 @@ protected:
                               UShort_t s,
                               UShort_t t,
                               Bool_t&  usedPrev, 
-                              Bool_t&  usedThis);
+                              Bool_t&  usedThis) const;
   /** 
    * Angle correct the signal 
    * 
index bbd3df2..55b1ac6 100644 (file)
@@ -2,6 +2,11 @@
 // Manager (singleton) of corrections 
 // 
 #include "AliForwardCorrectionManager.h"
+#include "AliFMDCorrDoubleHit.h"
+#include "AliFMDCorrELossFit.h"
+#include "AliFMDCorrVertexBias.h"
+#include "AliFMDCorrMergingEfficiency.h"
+#include "AliFMDCorrAcceptance.h"
 #include "AliForwardUtil.h"
 #include <TString.h>
 #include <AliLog.h>
@@ -130,6 +135,10 @@ AliForwardCorrectionManager::operator=(const AliForwardCorrectionManager& o)
 void
 AliForwardCorrectionManager::SetPrefix(const char* prefix)
 {
+  /** 
+   *
+   * @param prefix Prefix to correction objects. 
+   */
   fELossFitsPath    = Form("%s/%s", prefix, ELOSSFIT_DIR);
   fMergingEffPath   = Form("%s/%s", prefix, MERGING_DIR); 
   fSecondaryMapPath = Form("%s/%s", prefix, SECONDARY_DIR);
@@ -142,16 +151,13 @@ AliForwardCorrectionManager::SetPrefix(const char* prefix)
 void
 AliForwardCorrectionManager::SetFileDir(ECorrection what, const char* dir)
 {
+  /** 
+   * Set the file directory for a type 
+   * 
+   * @param what     Type 
+   * @param dirname  Directory name 
+   */
   TString *path = 0;
-  // 
-  // Get the path to the specified object 
-  // 
-  // Parameters:
-  //    what  Which stuff to get the path for 
-  // 
-  // Return:
-  //    The full path or null 
-  //
   if      (what & kSecondaryMap)        path = &fSecondaryMapPath;
   else if (what & kDoubleHit)           path = &fDoubleHitPath;
   else if (what & kELossFits)           path = &fELossFitsPath;
@@ -833,6 +839,9 @@ AliForwardCorrectionManager::ReadAcceptance(UShort_t sys,
 void
 AliForwardCorrectionManager::Print(Option_t* option) const
 {
+  // 
+  // Print stuff 
+  //
   char ind[gROOT->GetDirLevel()+1];
   for (Int_t i = 0; i < gROOT->GetDirLevel(); i++) ind[i] = ' ';
   ind[gROOT->GetDirLevel()] = '\0';
@@ -889,6 +898,9 @@ AliForwardCorrectionManager::Print(Option_t* option) const
 void
 AliForwardCorrectionManager::Browse(TBrowser* b)
 {
+  // 
+  // Browse thos
+  // 
   if (fELossFit)         b->Add(fELossFit,          "Energy loss fits");
   if (fSecondaryMap)     b->Add(fSecondaryMap,      "Secondary particle corr");
   if (fDoubleHit)        b->Add(fDoubleHit,         "Double hit corr");
@@ -901,18 +913,19 @@ AliForwardCorrectionManager::Browse(TBrowser* b)
 //______________________________________________________________________________
 void AliForwardCorrectionManager::Streamer(TBuffer &R__b)
 {
-   // Stream an object of class AliForwardCorrectionManager.
-
-   if (R__b.IsReading()) {
-      R__b.ReadClassBuffer(AliForwardCorrectionManager::Class(),this);
-      if (fgInstance) 
-       AliWarning(Form("Singleton instance already set (%p) when reading "
-                       "singleton object (%p).  Read object will be new "
-                       "singleton object", fgInstance, this));
-      fgInstance = this;
-   } else {
-      R__b.WriteClassBuffer(AliForwardCorrectionManager::Class(),this);
-   }
+  //
+  // Stream an object of class AliForwardCorrectionManager.
+  //
+  if (R__b.IsReading()) {
+     R__b.ReadClassBuffer(AliForwardCorrectionManager::Class(),this);
+     if (fgInstance) 
+       AliWarning(Form("Singleton instance already set (%p) when reading "
+                      "singleton object (%p).  Read object will be new "
+                      "singleton object", fgInstance, this));
+     fgInstance = this;
+  } else {
+    R__b.WriteClassBuffer(AliForwardCorrectionManager::Class(),this);
+  }
 }
 #endif
 #if 0
index 8812628..d705c2e 100644 (file)
@@ -4,15 +4,21 @@
 #ifndef ALIFORWARDCORRECTIONMANAGER_H
 #define ALIFORWARDCORRECTIONMANAGER_H
 #include <TObject.h>
-#include "AliFMDCorrELossFit.h"
+// #include "AliFMDCorrELossFit.h"
 #include "AliFMDCorrSecondaryMap.h"
-#include "AliFMDCorrDoubleHit.h"
-#include "AliFMDCorrVertexBias.h"
-#include "AliFMDCorrMergingEfficiency.h"
-#include "AliFMDCorrAcceptance.h"
+// #include "AliFMDCorrDoubleHit.h"
+// #include "AliFMDCorrVertexBias.h"
+// #include "AliFMDCorrMergingEfficiency.h"
+// #include "AliFMDCorrAcceptance.h"
 #include <TString.h>
 class TFile;
 class TBrowser;
+class AliFMDCorrELossFit;
+// class AliFMDCorrSecondaryMap;
+class AliFMDCorrDoubleHit;
+class AliFMDCorrVertexBias;
+class AliFMDCorrMergingEfficiency;
+class AliFMDCorrAcceptance;
 
 /**
  * Manager (singleton) of corrections 
@@ -60,6 +66,12 @@ public:
    * @param prefix Prefix to correction objects. 
    */
   void SetPrefix(const char* prefix);
+  /** 
+   * Set the file directory for a type 
+   * 
+   * @param what     Type 
+   * @param dirname  Directory name 
+   */
   void SetFileDir(ECorrection what, const char* dirname);
   void SetSecondaryMapPath(const char* d) { SetFileDir(kSecondaryMap, d); }
   void SetDoubleHitPath(const char* d)    { SetFileDir(kDoubleHit, d); }
@@ -394,7 +406,7 @@ private:
    */
   
   /** Static singleton instance */
-  static AliForwardCorrectionManager* fgInstance;
+  static AliForwardCorrectionManager* fgInstance; // Skeleton
   Bool_t    fInit;  // whether we have been initialised 
   UShort_t  fSys;   // Collision System
   UShort_t  fSNN;   // Collision energy per nucleon (GeV)
index 068325c..1fda2c5 100644 (file)
 //#include "AliFMDStripIndex.h"
 #include <TH1.h>
 #include <TH3D.h>
+#include <TH2D.h>
 #include <TDirectory.h>
 #include <TTree.h>
+#include <TList.h>
 
 //====================================================================
 namespace {
index 00776c2..720ceaf 100644 (file)
@@ -4,12 +4,6 @@
 #ifndef ALIFORWARDMCCORRECTIONS_H
 #define ALIFORWARDMCCORRECTIONS_H
 #include <AliAnalysisTaskSE.h>
-#include "AliForwardUtil.h"
-#include "AliFMDSharingFilter.h"
-#include "AliFMDDensityCalculator.h"
-#include "AliFMDCorrector.h"
-#include "AliFMDHistCollector.h"
-#include "AliAODForwardMult.h"
 #include <AliESDFMD.h>
 #include <TH1I.h>
 class AliFMDAnaParameters;
index 29a9e7d..86e6373 100644 (file)
@@ -14,6 +14,7 @@
 // Corrections used 
 #include "AliForwardMultiplicityBase.h"
 #include "AliForwardCorrectionManager.h"
+#include "AliForwardUtil.h"
 #include "AliLog.h"
 #include "AliAODHandler.h"
 #include "AliInputEventHandler.h"
@@ -26,6 +27,7 @@
 #include "AliFMDHistCollector.h"
 #include "AliESDEvent.h"
 #include <TROOT.h>
+#include <TAxis.h>
 #include <iostream>
 #include <iomanip>
 
@@ -41,6 +43,16 @@ AliForwardMultiplicityBase::AliForwardMultiplicityBase(const char* name)
 }
 
 //____________________________________________________________________
+AliForwardMultiplicityBase& 
+AliForwardMultiplicityBase::operator=(const AliForwardMultiplicityBase& o)
+{
+  fEnableLowFlux = o.fEnableLowFlux;
+  fFirstEvent    = o.fFirstEvent;
+  fCorrManager   = o.fCorrManager;
+  return *this;
+}
+
+//____________________________________________________________________
 Bool_t 
 AliForwardMultiplicityBase::CheckCorrections(UInt_t what) const
 {
@@ -106,6 +118,10 @@ AliForwardMultiplicityBase::ReadCorrections(const TAxis*& pe,
                                            const TAxis*& pv, 
                                            Bool_t        mc)
 {
+  //
+  // Read corrections
+  //
+  //
   UInt_t what = AliForwardCorrectionManager::kAll;
   if (!fEnableLowFlux)
     what ^= AliForwardCorrectionManager::kDoubleHit;
@@ -144,6 +160,9 @@ AliForwardMultiplicityBase::ReadCorrections(const TAxis*& pe,
 AliESDEvent*
 AliForwardMultiplicityBase::GetESDEvent()
 {
+  //
+  // Get the ESD event. IF this is the first event, initialise
+  //
   AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
   if (!esd) {
     AliWarning("No ESD event found for input event");
index 4b426dd..57f6de2 100644 (file)
@@ -5,7 +5,6 @@
 #ifndef ALIFORWARDMULTIPLICITYBASE_H
 #define ALIFORWARDMULTIPLICITYBASE_H
 #include <AliAnalysisTaskSE.h>
-#include "AliForwardUtil.h"
 class AliFMDEventInspector;
 class AliFMDEnergyFitter;
 class AliFMDSharingFilter;
@@ -17,7 +16,7 @@ class AliESDEvent;
 class TH2D;
 class TList;
 class TTree;
-
+class TAxis;
 
 /** 
  * @mainpage ALICE PWG2 Forward Multiplcity Analysis 
@@ -212,13 +211,7 @@ protected:
    * 
    * @return Reference to this object 
    */
-  AliForwardMultiplicityBase& operator=(const AliForwardMultiplicityBase& o)
-  {
-    fEnableLowFlux = o.fEnableLowFlux;
-    fFirstEvent    = o.fFirstEvent;
-    fCorrManager   = o.fCorrManager;
-    return *this;
-  }
+  AliForwardMultiplicityBase& operator=(const AliForwardMultiplicityBase& o);
   /** 
    * Check if all needed corrections are there and accounted for.  If not,
    * do a Fatal exit 
index e1fe70d..e3d29b8 100644 (file)
@@ -419,7 +419,7 @@ AliForwardUtil::IdLandauGausdPar(Double_t x,
 Double_t 
 AliForwardUtil::NLandauGaus(Double_t x, Double_t delta, Double_t xi, 
                            Double_t sigma, Double_t sigmaN, Int_t n, 
-                           Double_t* a)
+                           const Double_t* a)
 {
   // 
   // Evaluate 
@@ -475,7 +475,7 @@ TF1*
 AliForwardUtil::MakeNLandauGaus(Double_t  c, 
                                Double_t  delta, Double_t xi, 
                                Double_t  sigma, Double_t sigmaN, Int_t n, 
-                               Double_t* a, 
+                               const Double_t* a, 
                                Double_t  xmin, Double_t xmax)
 {
   // 
@@ -848,7 +848,7 @@ AliForwardUtil::RingHistos::DefineOutputList(TList* d) const
 }
 //____________________________________________________________________
 TList*
-AliForwardUtil::RingHistos::GetOutputList(TList* d) const
+AliForwardUtil::RingHistos::GetOutputList(const TList* d) const
 {
   // 
   // Get our output list from the container @a d
@@ -866,7 +866,7 @@ AliForwardUtil::RingHistos::GetOutputList(TList* d) const
 
 //____________________________________________________________________
 TH1*
-AliForwardUtil::RingHistos::GetOutputHist(TList* d, const char* name) const
+AliForwardUtil::RingHistos::GetOutputHist(const TList* d, const char* name) const
 {
   // 
   // Find a specific histogram in the source list @a d
index d49d0c9..4857543 100644 (file)
@@ -118,13 +118,13 @@ public:
   /**
    * Number of steps to do in the Landau, Gaussiam convolution 
    */
-  static Int_t fgConvolutionSteps;
+  static Int_t fgConvolutionSteps; // Number of convolution steps
   //------------------------------------------------------------------
   /** 
    * How many sigma's of the Gaussian in the Landau, Gaussian
    * convolution to integrate over
    */
-  static Double_t fgConvolutionNSigma;
+  static Double_t fgConvolutionNSigma; // Number of convolution sigmas 
   //------------------------------------------------------------------
   /** 
    * Calculate the shifted Landau
@@ -274,7 +274,7 @@ public:
    */
   static Double_t NLandauGaus(Double_t x, Double_t delta, Double_t xi, 
                              Double_t sigma, Double_t sigma_n, Int_t n, 
-                             Double_t* a);
+                             const Double_t* a);
   /** 
    * Generate a TF1 object of @f$ f_I@f$ 
    * 
@@ -313,7 +313,7 @@ public:
   static TF1* MakeNLandauGaus(Double_t c, 
                              Double_t delta, Double_t  xi, 
                              Double_t sigma, Double_t  sigma_n,
-                             Int_t    n,     Double_t* a, 
+                             Int_t    n,     const Double_t* a, 
                              Double_t xmin,  Double_t  xmax);
                                                    
   //__________________________________________________________________
@@ -378,8 +378,49 @@ public:
      * @return The function fitted to the data 
      */
     TF1* FitNParticle(TH1* dist, UShort_t n, Double_t sigman=-1);
-     
-
+    /**
+     * Get Lower cut on data 
+     *
+     * @return Lower cut on data 
+     */
+    Double_t GetLowCut() const { return fLowCut; }
+    /**
+     * Get Maximum range to fit 
+     *
+     * @return Maximum range to fit 
+     */
+    Double_t GetMaxRange() const { return fMaxRange; }
+    /**
+     * Get Number of bins from maximum to fit 1st peak
+     *
+     * @return Number of bins from maximum to fit 1st peak
+     */
+    UShort_t GetMinusBins() const { return fMinusBins; }
+    /**
+     * Get Array of fit results 
+     *
+     * @return Array of fit results 
+     */
+    const TObjArray& GetFitResults() const { return fFitResults; }
+    /** 
+     * Get Array of fit results  
+     *
+     * @return Array of fit results 
+     */
+    TObjArray& GetFitResults() { return fFitResults; }
+    /**
+     * Get Array of functions 
+     *
+     * @return Array of functions 
+     */
+    const TObjArray& GetFunctions() const { return fFunctions; }
+    /** 
+     * Get Array of functions  
+     *
+     * @return Array of functions 
+     */
+    TObjArray& GetFunctions() { return fFunctions; }
+  private:
     const Double_t fLowCut;     // Lower cut on data 
     const Double_t fMaxRange;   // Maximum range to fit 
     const UShort_t fMinusBins;  // Number of bins from maximum to fit 1st peak
@@ -535,7 +576,7 @@ public:
      * 
      * @return The found TList or null
      */
-    TList* GetOutputList(TList* d) const;
+    TList* GetOutputList(const TList* d) const;
     /** 
      * Find a specific histogram in the source list @a d
      * 
@@ -544,7 +585,7 @@ public:
      * 
      * @return Found histogram or null
      */
-    TH1* GetOutputHist(TList* d, const char* name) const;
+    TH1* GetOutputHist(const TList* d, const char* name) const;
     /** 
      * 
      * 
index 4d358a8..790ee19 100644 (file)
@@ -18,7 +18,11 @@ AliForwarddNdetaTask::AliForwarddNdetaTask()
     fSumPrimary(0),    //  Sum of primary histograms
     fSNNString(0),
     fSysString(0)
-{}
+{
+  //
+  // Constructor 
+  // 
+}
 
 //____________________________________________________________________
 AliForwarddNdetaTask::AliForwarddNdetaTask(const char* /* name */)
@@ -27,6 +31,11 @@ AliForwarddNdetaTask::AliForwarddNdetaTask(const char* /* name */)
     fSNNString(0),
     fSysString(0)
 {
+  // 
+  // Constructor
+  // 
+  // Paramters
+  //   name    Name of task 
 }
 
 //____________________________________________________________________
@@ -35,12 +44,26 @@ AliForwarddNdetaTask::AliForwarddNdetaTask(const AliForwarddNdetaTask& o)
     fSumPrimary(o.fSumPrimary),           // Sum of primary histograms
     fSNNString(o.fSNNString),     //  
     fSysString(o.fSysString)      //  
-{}
+{
+  // 
+  // Copy constructor
+  // 
+}
 
 //____________________________________________________________________
 TH2D*
-AliForwarddNdetaTask::GetHistogram(AliAODEvent* aod, Bool_t mc)
+AliForwarddNdetaTask::GetHistogram(const AliAODEvent* aod, Bool_t mc)
 {
+  // 
+  // Retrieve the histogram 
+  // 
+  // Parameters:
+  //    aod AOD event 
+  //    mc  Whether to get the MC histogram or not
+  // 
+  // Return:
+  //    Retrieved histogram or null
+  //
   TObject* obj = 0;
   if (mc) obj = aod->FindListObject("ForwardMC");
   else    obj = aod->FindListObject("Forward");
@@ -72,11 +95,11 @@ AliForwarddNdetaTask::GetHistogram(AliAODEvent* aod, Bool_t mc)
       
       
       /*   if(fTriggerMask == AliAODForwardMult::kNSD && forward->IsTriggerBits(AliAODForwardMult::kMCNSD)) {
-       if (primary) fSumPrimary->Add(primary); 
-      
-      }
-      
-      else if (primary) fSumPrimary->Add(primary);*/
+          if (primary) fSumPrimary->Add(primary); 
+          
+          }
+          
+          else if (primary) fSumPrimary->Add(primary);*/
       
     }    
   }
index 6173326..ff12e59 100644 (file)
@@ -59,10 +59,10 @@ protected:
    * 
    * @return Retrieved histogram or null
    */
-  TH2D* GetHistogram(AliAODEvent* aod, Bool_t mc);
+  TH2D* GetHistogram(const AliAODEvent* aod, Bool_t mc);
   TH2D*           fSumPrimary;    //  Sum of primary histograms
-  TNamed*         fSNNString;     // 
-  TNamed*         fSysString;     // 
+  TNamed*         fSNNString;     //  sqrt(s_NN) string 
+  TNamed*         fSysString;     //  Collision system string 
 
   ClassDef(AliForwarddNdetaTask,1); // Determine multiplicity in forward region
 };
diff --git a/PWG2/FORWARD/analysis2/older/AliFMDHistCollector.cxx b/PWG2/FORWARD/analysis2/older/AliFMDHistCollector.cxx
deleted file mode 100644 (file)
index 565d0a8..0000000
+++ /dev/null
@@ -1,703 +0,0 @@
-
-#include "AliFMDHistCollector.h"
-#include <AliESDFMD.h>
-#include <TAxis.h>
-#include <TList.h>
-#include <TMath.h>
-#include "AliFMDAnaParameters.h"
-#include "AliLog.h"
-#include <TH2D.h>
-#include <TH1I.h>
-#include <TProfile.h>
-#include <TProfile2D.h>
-#include <TArrayI.h>
-
-ClassImp(AliFMDHistCollector)
-#if 0
-; // For Emacs
-#endif 
-
-//____________________________________________________________________
-AliFMDHistCollector::AliFMDHistCollector()
-  : TNamed(), 
-    fList(), 
-    fNEvents(0),
-    fNCutBins(0),
-    fCorrectionCut(0),
-    fFirstBins(),
-    fLastBins(), 
-    fUseEtaFromData(kFALSE),
-    fEtaNorm(0), 
-    fOutput()
-{}
-
-//____________________________________________________________________
-AliFMDHistCollector::AliFMDHistCollector(const char* title)
-  : TNamed("fmdHistCollector", title), 
-    fList(), 
-    fNEvents(0),
-    fNCutBins(1), 
-    fCorrectionCut(0.5),
-    fFirstBins(1),
-    fLastBins(1), 
-    fUseEtaFromData(kFALSE),
-    fEtaNorm(0), 
-    fOutput()
-{
-  fList.SetName(GetName());
-  fOutput.SetName(GetName());
-}
-
-//____________________________________________________________________
-AliFMDHistCollector::AliFMDHistCollector(const AliFMDHistCollector& o)
-  : TNamed(o), 
-    fList(), 
-    fNEvents(o.fNEvents),
-    fNCutBins(o.fNCutBins), 
-    fCorrectionCut(o.fCorrectionCut),
-    fFirstBins(o.fFirstBins),
-    fLastBins(o.fLastBins), 
-    fUseEtaFromData(o.fUseEtaFromData),
-    fEtaNorm(o.fEtaNorm), 
-    fOutput()
-{
-
-  TObject* obj = 0;
-  TIter nextL(&o.fList);
-  while ((obj = nextL())) fList.Add(obj->Clone());
-  TIter nextO(&o.fOutput);
-  while ((obj = nextO())) fOutput.Add(obj->Clone());
-}
-
-//____________________________________________________________________
-AliFMDHistCollector::~AliFMDHistCollector()
-{
-  fList.Delete();
-  fOutput.Delete();
-  if (fEtaNorm) delete fEtaNorm;
-}
-
-//____________________________________________________________________
-AliFMDHistCollector&
-AliFMDHistCollector::operator=(const AliFMDHistCollector& o)
-{
-  SetName(o.GetName());
-  SetTitle(o.GetTitle());
-  if (fEtaNorm) delete fEtaNorm;
-  fList.Delete();
-  fOutput.Delete();
-
-  fNEvents        = o.fNEvents;
-  fNCutBins       = o.fNCutBins;
-  fCorrectionCut  = o.fCorrectionCut;
-  fFirstBins      = o.fFirstBins;
-  fLastBins       = o.fLastBins;
-  fUseEtaFromData = o.fUseEtaFromData;
-
-  TObject* obj = 0;
-  TIter nextL(&o.fList);
-  while ((obj = nextL())) fList.Add(obj->Clone());
-  TIter nextO(&o.fOutput);
-  while ((obj = nextO())) fOutput.Add(obj->Clone());
-  
-  return *this;
-}
-
-//____________________________________________________________________
-void
-AliFMDHistCollector::Init(const TAxis& vtxAxis, const TAxis& etaAxis)
-{
-  AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
-
-  Int_t nVz = vtxAxis.GetNbins();
-  fFirstBins.Set(5*nVz);
-  fLastBins.Set(5*nVz);
-
-  // Find the eta bin ranges 
-  for (Int_t iVz = 0; iVz < nVz; iVz++) {
-    AliForwardUtil::Histos* h = new AliForwardUtil::Histos;
-    h->Init(etaAxis);
-    fList.AddAt(h, iVz);
-
-    // Find the first and last eta bin to use for each ring for 
-    // each vertex bin.   This is instead of using the methods 
-    // provided by AliFMDAnaParameters 
-    for (Int_t iIdx = 0; iIdx < 5; iIdx++) {
-      UShort_t d = 0;
-      Char_t   r = 0;
-      GetDetRing(iIdx, d, r);
-      
-      // Get the background object 
-      TH2F* bg    = pars->GetBackgroundCorrection(d,r,iVz);
-      Int_t nEta  = bg->GetNbinsX();
-      Int_t first = nEta+1;
-      Int_t last  = 0;
-
-      // Loop over the eta bins 
-      for (Int_t ie = 1; ie <= nEta; ie++) { 
-       if (bg->GetBinContent(ie,1) < fCorrectionCut) continue;
-
-       // Loop over the phi bins to make sure that we 
-       // do not have holes in the coverage 
-       bool ok = true;
-       for (Int_t ip = 1; ip <= bg->GetNbinsY(); ip++) { 
-         if (bg->GetBinContent(ie,ip) < 0.001) {
-           ok = false;
-           continue;
-         }
-       }
-       if (!ok) continue;
-
-       first = TMath::Min(ie, first);
-       last  = TMath::Max(ie, last);
-      }
-      
-      // Store the result for later use 
-      fFirstBins[iVz*5+iIdx] = first;
-      fLastBins[iVz*5+iIdx]  = last;
-    } // for j 
-  }
-
-  // Next, using the ranges found above, do the eta acceptance
-  // normalisation.
-  fEtaNorm = new TH1F("etaAcceptance", "Acceptance in eta", 
-                     etaAxis.GetNbins(), 
-                     etaAxis.GetXmin(), 
-                     etaAxis.GetXmax());
-  fEtaNorm->SetDirectory(0);
-  fEtaNorm->SetFillColor(kRed+1);
-  fEtaNorm->SetFillStyle(3001);
-  
-  TH1F* tmp = new TH1F("tmp", "tmp", 
-                     etaAxis.GetNbins(), 
-                     etaAxis.GetXmin(), 
-                     etaAxis.GetXmax());
-  tmp->SetDirectory(0);
-  TH2D* bg = new TH2D("bg", "Background map", 
-                     etaAxis.GetNbins(), etaAxis.GetXmin(),etaAxis.GetXmax(),
-                     20, 0, 2*TMath::Pi());
-  bg->SetDirectory(0);
-
-  Int_t colors[] = { kRed,   kPink, kMagenta, kViolet, kBlue, 
-                    kAzure, kCyan, kTeal,    kGreen,  kSpring };
-
-
-  // Loop over the vertex bins 
-  for (Int_t iVz = 0; iVz < nVz; iVz++) { 
-    // Clear cache 
-    tmp->Reset();
-    tmp->SetFillColor(colors[iVz % 10] + iVz/10);
-    tmp->SetFillStyle(3001);
-
-    bg->Reset();
-    TList* vzList = new TList;
-    vzList->SetName(Form("vtxbin%02d", iVz));
-    fOutput.AddAt(vzList, iVz);
-
-    // Loop over rings 
-    for (Int_t d = 1; d <= 3; d++) { 
-      Int_t nq = (d == 1 ? 1 : 2);
-      for (Int_t q = 0; q < nq; q++) { 
-       Char_t r = (q == 0 ? 'I' : 'O'); 
-       
-       // Get the first and last bin to use 
-       Int_t first, last;
-       GetFirstAndLast(d, r, iVz, first, last);
-       
-       TH2F* ibg = static_cast<TH2F*>(pars->GetBackgroundCorrection(d,r,iVz)
-                                      ->Clone("bg"));
-
-       // Zero out-side of selected range 
-       if (q == 1) { ibg->RebinY(2); ibg->Scale(0.5); }
-       for (Int_t iEta = 1; iEta < first; iEta++) 
-         for (Int_t iPhi = 1; iPhi <= 20; iPhi++) 
-           ibg->SetBinContent(iEta,iPhi,0);
-       for (Int_t iEta = last+1; iEta <= etaAxis.GetNbins(); iEta++) 
-         for (Int_t iPhi = 1; iPhi <= 20; iPhi++) 
-           ibg->SetBinContent(iEta,iPhi,0);
-       // Add to output 
-       bg->Add(ibg);
-       delete ibg;
-
-       // Loop over the eta bins 
-       for (Int_t iEta = first; iEta <= last; iEta++) {
-         Int_t   overlap = GetOverlap(d,r,iEta,iVz);
-         Float_t oc      = tmp->GetBinContent(iEta);
-         Float_t nc      = overlap >= 0? 0.5 : 1;
-         tmp->SetBinContent(iEta, oc + nc);
-       }
-      }
-    }
-    vzList->Add(tmp->Clone("etaAcceptance"));
-    vzList->Add(bg->Clone("secondaryMap"));
-    fEtaNorm->Add(tmp);
-  }
-  fEtaNorm->Scale(1. / nVz);
-  fOutput.Add(fEtaNorm);
-  delete tmp;
-  delete bg;
-
-}
-
-//____________________________________________________________________
-Int_t
-AliFMDHistCollector::GetIdx(UShort_t d, Char_t r) const
-{
-  Int_t idx = -1;
-  switch (d) { 
-  case 1: idx = 0; break;
-  case 2: idx = 1 + (r == 'I' || r == 'i' ? 0 : 1); break;
-  case 3: idx = 3 + (r == 'I' || r == 'i' ? 0 : 1); break;
-  }
-  return idx;
-}
-//____________________________________________________________________
-void
-AliFMDHistCollector::GetDetRing(Int_t idx, UShort_t& d, Char_t& r) const
-{
-  d = 0; 
-  r = '\0';
-  switch (idx) { 
-  case 0: d = 1; r = 'I'; break;
-  case 1: d = 2; r = 'I'; break;
-  case 2: d = 2; r = 'O'; break;
-  case 3: d = 3; r = 'I'; break;
-  case 4: d = 3; r = 'O'; break;
-  }
-}
-
-//____________________________________________________________________
-void
-AliFMDHistCollector::GetFirstAndLast(Int_t idx, Int_t vtxbin, 
-                                    Int_t& first, Int_t& last) const
-{
-  first = 0; 
-  last  = 0;
-  
-  if (idx < 0) return;
-  idx += vtxbin * 5;
-      
-  if (idx < 0 || idx >= fFirstBins.GetSize()) return;
-  
-  first = fFirstBins.At(idx)+fNCutBins;  
-  last  = fLastBins.At(idx)-fNCutBins;
-}
-
-//____________________________________________________________________
-Int_t
-AliFMDHistCollector::GetFirst(Int_t idx, Int_t v) const 
-{
-  Int_t f, l;
-  GetFirstAndLast(idx,v,f,l);
-  return f;
-}
-
-
-//____________________________________________________________________
-Int_t
-AliFMDHistCollector::GetLast(Int_t idx, Int_t v) const 
-{
-  Int_t f, l;
-  GetFirstAndLast(idx,v,f,l);
-  return l;
-}
-
-//____________________________________________________________________
-Int_t 
-AliFMDHistCollector::GetOverlap(UShort_t d, Char_t r, 
-                               Int_t bin, Int_t vtxbin) const
-{
-  // Get the possibly overlapping histogram 
-  Int_t other = -1;
-  if (d == 1) {
-    if (bin <= GetLast(2,'I',vtxbin)) other = GetIdx(2,'I');
-  }
-  else if (d == 2 && r == 'I') {
-    if      (bin <= GetLast(2,  'O', vtxbin)) other = GetIdx(2, 'O');
-    else if (bin >= GetFirst(1, 'I', vtxbin)) other = GetIdx(1, 'I');
-  }
-  else if (d == 2 && r == 'O') {
-    if (bin >= GetFirst(2, 'I', vtxbin)) other = GetIdx(2,'I');
-  }
-  else if (d == 3 && r == 'O') {
-    if (bin <= GetLast(3, 'I', vtxbin)) other = GetIdx(3, 'I');
-  }
-  else if (d == 3 && r == 'I') {
-    if (bin >= GetFirst(3, 'O', vtxbin)) other = GetIdx(3, 'O');
-  }
-  // AliInfo(Form("FMD%d%c (%d) -> %d", d, r, GetIdx(d,r), other));
-  return other;
-}
-//____________________________________________________________________
-Int_t
-AliFMDHistCollector::GetOverlap(Int_t idx, Int_t bin, Int_t vtxbin) const
-{
-  UShort_t d = 0; 
-  Char_t   r = '\0';
-  GetDetRing(idx, d, r);
-  if (d == 0 || r == '\0') return 0;
-
-  return GetOverlap(d, r, bin, vtxbin);
-}
-  
-  
-//____________________________________________________________________
-Bool_t
-AliFMDHistCollector::Collect(AliForwardUtil::Histos& hists,
-                            Int_t                   vtxbin, 
-                            TH2D&                   out)
-{
-  if (fList.GetEntries() <= vtxbin) {
-    AliWarning(Form("Vertex bin %d out of range [0,%d]", 
-                   vtxbin, fList.GetEntries()));
-    return kFALSE;
-  }
-  
-  Merge(hists, vtxbin, out);
-  Store(hists, vtxbin);
-
-  return kTRUE;
-}
-
-//____________________________________________________________________
-void
-AliFMDHistCollector::Store(AliForwardUtil::Histos& hists,
-                          Int_t                   vtxbin)
-{
-  AliForwardUtil::Histos* histos = 
-    static_cast<AliForwardUtil::Histos*>(fList.At(vtxbin));
-  if (!histos) { 
-    AliWarning(Form("No histogram for vertex bin %d", vtxbin));
-    return;
-  }
-  if (!histos->fFMD1i || 
-      !histos->fFMD2i || 
-      !histos->fFMD2o || 
-      !histos->fFMD3i || 
-      !histos->fFMD3o) { 
-    AliWarning(Form("Histograms for vertex bin %d not initialised "
-                   "(%p,%p,%p,%p,%p)", vtxbin, 
-                   histos->fFMD1i, histos->fFMD2i, histos->fFMD2o,
-                   histos->fFMD3i, histos->fFMD3o));
-    return;
-  }
-  if (!hists.fFMD1i || 
-      !hists.fFMD2i || 
-      !hists.fFMD2o || 
-      !hists.fFMD3i || 
-      !hists.fFMD3o) { 
-    AliWarning(Form("Cache histograms not initialised (%p,%p,%p,%p,%p)",
-                   hists.fFMD1i, hists.fFMD2i, hists.fFMD2o,
-                   hists.fFMD3i, hists.fFMD3o));
-    return;
-  }
-
-  histos->fFMD1i->Add(hists.fFMD1i);
-  histos->fFMD2i->Add(hists.fFMD2i);
-  histos->fFMD2o->Add(hists.fFMD2o);
-  histos->fFMD3i->Add(hists.fFMD3i);
-  histos->fFMD3o->Add(hists.fFMD3o);
-}
-
-
-//____________________________________________________________________
-void
-AliFMDHistCollector::Merge(AliForwardUtil::Histos& hists,
-                          Int_t                   vtxbin, 
-                          TH2D&                   out)
-{
-  // AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
-  Bool_t isProfile = (out.InheritsFrom(TProfile2D::Class()));
-
-  for (UShort_t d=1; d<=3; d++) { 
-    UShort_t nr = (d == 1 ? 1 : 2);
-    for (UShort_t q=0; q<nr; q++) { 
-      Char_t      r = (q == 0 ? 'I' : 'O');
-      TH2D*       h = hists.Get(d,r);
-      TH2D*       t = static_cast<TH2D*>(h->Clone(Form("FMD%d%c_tmp",d,r)));
-      
-      // Outer rings have better phi segmentation - rebin to same as inner. 
-      if (q == 1) t->RebinY(2);
-
-      Int_t first = 0;
-      Int_t last  = 0;
-      GetFirstAndLast(d, r, vtxbin, first, last);
-
-      // Now update profile output 
-      for (Int_t iEta = first; iEta <= last; iEta++) { 
-
-       // Get the possibly overlapping histogram 
-       Int_t overlap = GetOverlap(d,r,iEta,vtxbin);
-
-       // Fill eta acceptance for this event into the phi underlow bin
-       Float_t ooc      = out.GetBinContent(iEta,0);
-       Float_t noc      = overlap >= 0? 0.5 : 1;
-       out.SetBinContent(iEta, 0, ooc + noc);
-
-       for (Int_t iPhi = 1; iPhi <= h->GetNbinsY(); iPhi++) { 
-         Double_t c = t->GetBinContent(iEta,iPhi);
-         Double_t e = t->GetBinError(iEta,iPhi);
-
-         // If there's no signal, continue 
-         // if (e <= 0) continue;
-         if (c <= 0 || e <= 0)     continue;
-         
-         if (isProfile) {
-           static_cast<TProfile2D&>(out).Fill(h->GetXaxis()->GetBinCenter(iEta), 
-                                              h->GetYaxis()->GetBinCenter(iPhi), 
-                                              c, e);
-           continue;
-         }
-         
-         // If there's no overlapping histogram (ring), then 
-         // fill in data and continue to the next phi bin 
-         if (overlap < 0) { 
-           out.SetBinContent(iEta,iPhi,c);
-           out.SetBinError(iEta,iPhi,e);
-           continue;
-         }
-
-         // Get the current bin content and error 
-         Double_t oc = out.GetBinContent(iEta,iPhi);
-         Double_t oe = out.GetBinError(iEta,iPhi);
-
-#define USE_STRAIGHT_MEAN
-// #define USE_STRAIGHT_MEAN_NONZERO
-// #define USE_WEIGHTED_MEAN
-// #define USE_MOST_CERTAIN
-#if defined(USE_STRAIGHT_MEAN)
-         // calculate the average of old value (half the original), 
-         // and this value, as well as the summed squared errors 
-         // of the existing content (sqrt((e_1/2)^2=sqrt(e_1^2/4)=e_1/2) 
-         // and half the error of this.   
-         //
-         // So, on the first overlapping histogram we get 
-         // 
-         //    c = c_1 / 2
-         //    e = sqrt((e_1 / 2)^2) = e_1/2
-         // 
-         // On the second we get 
-         // 
-         //    c' = c_2 / 2 + c = c_2 / 2 + c_1 / 2 = (c_1+c_2)/2 
-         //    e' = sqrt(e^2 + (e_2/2)^2) 
-         //       = sqrt(e_1^2/4 + e_2^2/4) 
-         //       = sqrt(1/4 * (e_1^2+e_2^2)) 
-         //       = 1/2 * sqrt(e_1^2 + e_2^2)
-         out.SetBinContent(iEta,iPhi,oc + c/2);
-         out.SetBinError(iEta,iPhi,TMath::Sqrt(oe*oe+(e*e)/4));
-#elif defined(USE_STRAIGHT_MEAN_NONZERO)
-# define ZERO_OTHER
-         // If there's data in the overlapping histogram, 
-         // calculate the average and add the errors in 
-         // quadrature.  
-         // 
-         // If there's no data in the overlapping histogram, 
-         // then just fill in the data 
-         if (oe > 0) {
-           out.SetBinContent(iEta,iPhi,(oc + c)/2);
-           out.SetBinError(iEta,iPhi,TMath::Sqrt(oe*oe + e*e)/2);
-         }
-         else {
-           out.SetBinContent(iEta,iPhi,c);
-           out.SetBinError(iEta,iPhi,e);
-         }         
-#elif defined(USE_WEIGHTED_MEAN) 
-         // Calculate the weighted mean 
-         Double_t w  = 1/(e*e);
-         Double_t sc = w * c;
-         Double_t sw = w;
-         if (oe > 0) {
-           Double_t ow = 1/(oe*oe);
-           sc          += ow * oc;
-           sw          += ow;
-         }
-         Double_t nc = sc / sw;
-         Double_t ne = TMath::Sqrt(1 / sw);
-         out.SetBinContent(iEta,iPhi,nc,ne);
-#elif defined(USE_MOST_CERTAIN)
-# define ZERO_OTHER
-         if (e < oe) {
-           out.SetBinContent(iEta,iPhi,c);
-           out.SetBinError(iEta,iPhi,e);
-         }
-         else {
-           out.SetBinContent(iEta,iPhi,oc);
-           out.SetBinError(iEta,iPhi,oe);
-         }
-#else 
-#         error No method for defining content of overlapping bins defined
-#endif
-#if defined(ZERO_OTHER)
-         // Get the content of the overlapping histogram, 
-         // and zero the content so that we won't use it 
-         // again 
-         UShort_t od; Char_t oR; 
-         GetDetRing(overlap, od, oR);
-         TH2D* other = hists.Get(od,oR);
-         other->SetBinContent(iEta,iPhi,0);
-         other->SetBinError(iEta,iPhi,0);
-#endif
-       }
-      }
-      // Remove temporary histogram 
-      delete t;
-    } // for r
-  } // for d 
-
-  // Scale the histogram to the bin size 
-  // Int_t    nEta = out.GetNbinsX();
-  // Int_t    nPhi = out.GetNbinsY();
-  // Double_t rEta = out.GetXaxis()->GetXmax()-out.GetXaxis()->GetXmin();
-  // Double_t rPhi = out.GetYaxis()->GetXmax()-out.GetYaxis()->GetXmin();
-  // out.Scale(1. / (rEta/nEta*rPhi/nPhi));
-  // out.Scale(1., "width"); //
-}
-
-//____________________________________________________________________
-void
-AliFMDHistCollector::ScaleHistograms(const TH1I& nEvents)
-{
-  fNEvents = &nEvents;
-
-#if 0
-  TIter    next(&fList);
-  AliForwardUtil::Histos* histos = 0;
-  Int_t i = 1;
-  while ((histos = static_cast<AliForwardUtil::Histos*>(next()))) {
-    Int_t nev = nEvents.GetBinContent(i++);
-    if (nev <= 0) continue;
-    histos->fFMD1i->Scale(1. / nev);
-    histos->fFMD2i->Scale(1. / nev);
-    histos->fFMD2o->Scale(1. / nev);
-    histos->fFMD3i->Scale(1. / nev);
-    histos->fFMD3o->Scale(1. / nev);
-  }
-#endif 
-}
-
-//____________________________________________________________________
-void
-AliFMDHistCollector::Output(TList* dir)
-{
-  dir->Add(&fOutput);
-
-  // The axis 
-  TAxis* eAxis = static_cast<AliForwardUtil::Histos*>(fList.At(0))
-    ->fFMD1i->GetXaxis();
-  TAxis* vAxis = fNEvents->GetXaxis();
-  Int_t  nVtx  = vAxis->GetNbins();
-
-  // Create profiles of each vertex bin 
-  TList  mults;
-  for (Int_t i = 0; i < nVtx; i++) {
-    TProfile* mult = new TProfile(Form("dndeta_vtx%02d", i), 
-                                 Form("dN_{ch}/d#eta %f<v_{z}<%f", 
-                                      fNEvents->GetXaxis()->GetBinLowEdge(i+1),
-                                      fNEvents->GetXaxis()->GetBinUpEdge(i+1)),
-                                 eAxis->GetNbins(),eAxis->GetXmin(),
-                                 eAxis->GetXmax());
-    mult->Sumw2();
-    mults.AddAt(mult, i);
-    fOutput.Add(mult);
-  }
-  // Loop over vertex bins 
-  for (Int_t iVtx = 0; iVtx < nVtx; iVtx++) {
-    AliForwardUtil::Histos* histos = 
-      static_cast<AliForwardUtil::Histos*>(fList.At(iVtx));
-      // Output list for this vertex 
-    TList* l = 
-      static_cast<TList*>(fOutput.FindObject(Form("vtxbin%02d", iVtx)));
-
-    // Number of events in this vertex bin 
-    Int_t nev = fNEvents->GetBinContent(iVtx+1);
-    if (nev <= 0) { 
-      continue;
-    }
-    
-    // One of the outputs 
-    TProfile* mult = static_cast<TProfile*>(mults.At(iVtx));
-    if (!mult) { 
-      AliWarning(Form("No multiplicity for vertex %d", iVtx));
-      continue;
-    }
-
-    // Array of histograms and iterator 
-    TH2D* hh[] = { histos->fFMD1i, histos->fFMD2i, histos->fFMD2o,
-                  histos->fFMD3i, histos->fFMD3o, 0 };
-    TH2D** pp = hh;
-    Int_t idx = 0;
-    while (*pp) { 
-      // (eta,phi) histogram of the ring in this vertex 
-      (*pp)->SetName(Form("d2ndetadphi_%s", (*pp)->GetName()));
-      // Projection (sum) over phi of each vertex histogram 
-      TH1D* h = (*pp)->ProjectionX(Form("%s_proj", (*pp)->GetName()));
-      // Scale to number of events and bin width 
-      h->Scale(1./nev, "width");
-      // add to output 
-      l->Add(h);
-
-      Int_t firstNonZero = h->GetNbinsX();
-      Int_t lastNonZero  = 0;
-      if (!fUseEtaFromData) {
-       GetFirstAndLast(idx, iVtx, firstNonZero, lastNonZero);
-       // firstNonZero += 2;
-       // lastNonZero -= 2;
-      }
-      else {
-       // Find first and las non-zerio bins 
-       for (Int_t j = 1; j <= h->GetNbinsX(); j++) { 
-         if (h->GetBinContent(j) != 0) { 
-           firstNonZero = TMath::Min(j, firstNonZero);
-           lastNonZero  = TMath::Max(j, lastNonZero);
-         }
-       }
-       firstNonZero += fNCutBins;
-       lastNonZero  -= fNCutBins;
-      }
-
-      // Fill profile histogram 
-      UShort_t d; Char_t r;
-      GetDetRing(idx, d, r);
-      for (Int_t iEta = firstNonZero; iEta <= lastNonZero; iEta++) {
-       Double_t c = h->GetBinContent(iEta);
-       Double_t e = h->GetBinError(iEta);
-       if (e <= 0) { 
-         AliWarning(Form("error=%f in bin %d of %s/vtx=%d", 
-                         e, iEta, h->GetName(), iVtx));
-         continue;
-       }
-       mult->Fill(h->GetBinCenter(iEta), c, e);
-      }
-      idx++;
-      pp++;
-    } // while (*pp)
-
-    // Loop again to output 2D hists
-    pp = hh;
-    while (*pp) { 
-      // (*pp)->Scale(1./nev, "width");
-      l->Add(*pp);
-      pp++;
-    }
-  } // for histos 
-
-  // Result 
-  TProfile* total = new TProfile("dndeta", "#frac{1}{N}#frac{dN_{ch}}{d#eta}", 
-                                eAxis->GetNbins(),eAxis->GetXmin(),
-                                eAxis->GetXmax());
-
-  
-  for (Int_t iVtx = 0; iVtx < vAxis->GetNbins(); iVtx++) { 
-    TProfile* mult = static_cast<TProfile*>(mults.At(iVtx));
-    total->Add(mult);
-  }
-  fOutput.Add(total);
-}
-
-//____________________________________________________________________
-//
-// EOF
-//
-         
-
-
diff --git a/PWG2/FORWARD/analysis2/older/AliFMDHistCollector.h b/PWG2/FORWARD/analysis2/older/AliFMDHistCollector.h
deleted file mode 100644 (file)
index 53e2d3c..0000000
+++ /dev/null
@@ -1,300 +0,0 @@
-#ifndef ALIROOT_PWG2_FORWARD_ANALYSIS2_ALIFMDHISTCOLLECTOR_H
-#define ALIROOT_PWG2_FORWARD_ANALYSIS2_ALIFMDHISTCOLLECTOR_H
-#include <TNamed.h>
-#include <TList.h>
-#include <TArrayI.h>
-#include "AliForwardUtil.h"
-class AliESDFMD;
-class TH2D;
-class TH1I;
-class TH1F;
-
-/** 
- * This class collects the event histograms into single histograms, 
- * one for each ring in each vertex bin.  
- *
- * @par Input:
- *   - AliESDFMD object possibly corrected for sharing
- *
- * @par Output:
- *   - 5 RingHistos objects - each with a number of vertex dependent 
- *     2D histograms of the inclusive charge particle density 
- * 
- * @par HistCollector used: 
- *   - AliFMDAnaCalibBackgroundCorrection
- *
- * @ingroup pwg2_forward_analysis 
- */
-class AliFMDHistCollector : public TNamed
-{
-public:
-  /** 
-   * Constructor 
-   */
-  AliFMDHistCollector();
-  /** 
-   * Constructor 
-   * 
-   * @param name Name of object
-   */
-  AliFMDHistCollector(const char* name);
-  /** 
-   * Copy constructor 
-   * 
-   * @param o Object to copy from 
-   */
-  AliFMDHistCollector(const AliFMDHistCollector& o);
-  /** 
-   * Destructor 
-   */
-  virtual ~AliFMDHistCollector();
-  /** 
-   * Assignement operator
-   * 
-   * @param o Object to assign from 
-   * 
-   * @return Reference to this object
-   */
-  AliFMDHistCollector& operator=(const AliFMDHistCollector&);
-  /** 
-   * Intialise 
-   * 
-   * @param vtxAxis  Vertex axis 
-   * @param etaAxis  Eta axis 
-   */  
-  virtual void Init(const TAxis& vtxAxis, const TAxis& etaAxis);
-  /** 
-   * Do the calculations 
-   * 
-   * @param hists    Cache of histograms 
-   * @param vtxBin   Vertex bin 
-   * @param out      Output histogram
-   * 
-   * @return true on successs 
-   */
-  virtual Bool_t Collect(AliForwardUtil::Histos& hists, Int_t vtxBin, 
-                        TH2D& out);
-  /** 
-   * Scale the histograms to the total number of events 
-   * 
-   * @param nEvents Number of events 
-   */
-  void ScaleHistograms(const TH1I& nEvents);
-  /** 
-   * Output diagnostic histograms to directory 
-   * 
-   * @param dir List to write in
-   */  
-  void Output(TList* dir);
-  /** 
-   * Set the number of extra bins (beyond the secondary map border) 
-   * to cut away. 
-   * 
-   * @param n Number of bins 
-   */
-  void SetNCutBins(UInt_t n=2) { fNCutBins = n; }
-  /** 
-   * Set the correction cut, that is, when bins in the secondary
-   * correction maps have a value lower than this cut, they are
-   * considered uncertain and not used
-   * 
-   * @param cut Cut-off 
-   */
-  void SetCorrectionCut(Float_t cut=0.5) { fCorrectionCut = cut; }
-  /** 
-   * Whether to use the eta range from the data 
-   * 
-   * @param use 
-   */
-  void UseEtaFromData(Bool_t use=kTRUE) { fUseEtaFromData = use; }
-protected:
-  /** 
-   * Add the 5 input histograms to our internal sum of vertex
-   * dependent histograms
-   * 
-   * @param hists   Result 
-   * @param vtxBin  Vertex bin 
-   */
-  virtual void Store(AliForwardUtil::Histos& hists, Int_t vtxBin);
-  /** 
-   * Merge the 5 input histograms into a single histogram
-   * 
-   * @param hists   Result
-   * @param vtxBin  Vertex bin
-   * @param out     Output histogram 
-   */
-  virtual void Merge(AliForwardUtil::Histos& hists, Int_t vtxBin, TH2D& out);
-  /** 
-   * Get the first and last eta bin to use for a given ring and vertex 
-   * 
-   * @param d        Detector
-   * @param r        Ring 
-   * @param vtxBin   Vertex bin 
-   * @param first    On return, the first eta bin to use 
-   * @param last     On return, the last eta bin to use 
-   */
-  virtual void GetFirstAndLast(UShort_t d, Char_t r, Int_t vtxBin, 
-                              Int_t& first, Int_t& last) const;
-  /** 
-   * Get the first and last eta bin to use for a given ring and vertex 
-   * 
-   * @param idx      Ring index as given by GetIdx
-   * @param vtxBin   Vertex bin 
-   * @param first    On return, the first eta bin to use 
-   * @param last     On return, the last eta bin to use 
-   */
-  virtual void GetFirstAndLast(Int_t idx, Int_t vtxBin, 
-                              Int_t& first, Int_t& last) const;
-  /** 
-   * Get the first eta bin to use for a given ring and vertex 
-   * 
-   * @param d Detector 
-   * @param r Ring 
-   * @param v vertex bin
-   * 
-   * @return First eta bin to use, or -1 in case of problems 
-   */  
-  Int_t GetFirst(UShort_t d, Char_t r, Int_t v) const; 
-  /** 
-   * Get the first eta bin to use for a given ring and vertex 
-   * 
-   * @param i Ring index as given by GetIdx
-   * @param v vertex bin
-   * 
-   * @return First eta bin to use, or -1 in case of problems 
-   */  
-  Int_t GetFirst(Int_t idx, Int_t v) const; 
-  /** 
-   * Get the last eta bin to use for a given ring and vertex 
-   * 
-   * @param d Detector 
-   * @param r Ring 
-   * @param v vertex bin
-   * 
-   * @return Last eta bin to use, or -1 in case of problems 
-   */  
-  Int_t GetLast(UShort_t d, Char_t r, Int_t v) const;
-  /** 
-   * Get the last eta bin to use for a given ring and vertex 
-   * 
-   * @param i Ring index as given by GetIdx
-   * @param v vertex bin
-   * 
-   * @return Last eta bin to use, or -1 in case of problems 
-   */  
-  Int_t GetLast(Int_t idx, Int_t v) const; 
-  /** 
-   * Get the detector and ring from the ring index 
-   * 
-   * @param idx Ring index 
-   * @param d   On return, the detector or 0 in case of errors 
-   * @param r   On return, the ring id or '\0' in case of errors 
-   */
-  void GetDetRing(Int_t idx, UShort_t& d, Char_t& r) const;
-  /** 
-   * Get the ring index from detector number and ring identifier 
-   * 
-   * @param d Detector
-   * @param r Ring identifier 
-   * 
-   * @return ring index or -1 in case of problems 
-   */
-  Int_t GetIdx(UShort_t d, Char_t r) const;
-  /** 
-   * Get the possibly overlapping histogram of eta bin @a e in 
-   * detector and ring 
-   * 
-   * @param d Detector
-   * @param r Ring 
-   * @param e Eta bin
-   * @param v Vertex bin
-   *
-   * @return Overlapping histogram index or -1
-   */
-  Int_t GetOverlap(UShort_t d, Char_t r, Int_t e, Int_t v) const;
-  /** 
-   * Get the possibly overlapping histogram of eta bin @a e in 
-   * detector and ring 
-   * 
-   * @param i Ring index
-   * @param e Eta bin
-   * @param v Vertex bin
-   *
-   * @return Overlapping histogram index or -1
-   */
-  Int_t GetOverlap(Int_t i, Int_t e, Int_t v) const;
-  /** 
-   * Check if there's an overlapping histogram with this eta bin of
-   * the detector and ring
-   * 
-   * @param d Detector 
-   * @param r Ring 
-   * @param e eta bin
-   * @param v Vertex bin
-   * 
-   * @return True if there's an overlapping histogram 
-   */
-  Bool_t HasOverlap(UShort_t d, Char_t r, Int_t e, Int_t v) const;
-  /** 
-   * Check if there's an overlapping histogram with this eta bin of
-   * ring
-   * 
-   * @param i Ring index
-   * @param e eta bin
-   * @param v Vertex bin
-   * 
-   * @return True if there's an overlapping histogram 
-   */
-  Bool_t HasOverlap(Int_t i, Int_t e, Int_t v) const;
-
-
-  TList       fList;            // List of histogram containers
-  const TH1I* fNEvents;         // Reference event histogram 
-  Int_t       fNCutBins;        // Number of additional bins to cut away
-  Float_t     fCorrectionCut;   // Cut-off on secondary corrections 
-  TArrayI     fFirstBins;       // Array of first eta bins 
-  TArrayI     fLastBins;        // Array of last eta bins 
-  Bool_t      fUseEtaFromData;  // Wether to use the data for the limits
-  TH1F*       fEtaNorm;         // Normalisation in eta 
-  TList       fOutput;
-
-  ClassDef(AliFMDHistCollector,1); // Calculate Nch density 
-};
-
-//____________________________________________________________________
-inline void
-AliFMDHistCollector::GetFirstAndLast(UShort_t d, Char_t r, Int_t vtxbin, 
-                                    Int_t& first, Int_t& last) const
-{
-  GetFirstAndLast(GetIdx(d,r), vtxbin, first, last);
-}
-//____________________________________________________________________
-inline Int_t
-AliFMDHistCollector::GetFirst(UShort_t d, Char_t r, Int_t v) const 
-{
-  return GetFirst(GetIdx(d,r), v);
-}
-//____________________________________________________________________
-inline Int_t
-AliFMDHistCollector::GetLast(UShort_t d, Char_t r, Int_t v) const 
-{
-  return GetLast(GetIdx(d, r), v);
-}
-//____________________________________________________________________
-inline Bool_t
-AliFMDHistCollector::HasOverlap(UShort_t d, Char_t r, Int_t e, Int_t v) const
-{
-  return GetOverlap(d,r,e,v) >= 0;
-}
-//____________________________________________________________________
-inline Bool_t
-AliFMDHistCollector::HasOverlap(Int_t i, Int_t e, Int_t v) const
-{
-  return GetOverlap(i,e,v) >= 0;
-}
-
-#endif
-// Local Variables:
-//   mode: C++
-// End:
-
diff --git a/PWG2/FORWARD/analysis2/older/DrawRes1D.C b/PWG2/FORWARD/analysis2/older/DrawRes1D.C
deleted file mode 100644 (file)
index 140b2d5..0000000
+++ /dev/null
@@ -1,143 +0,0 @@
-#include "DrawResBase.h"
-
-/** 
- * @defgroup pwg2_forward_analysis_scripts PWG2 Forward analysis - scripts
- *
- * @ingroup pwg2_forward_analysis
- */
-/** 
- * Example macro to loop over the event-by-event 2D histogram of 
- * @f[
- *   \frac{d^{2}N_{ch}}{d\eta\,d\phi}
- * @f]
- * stored in an AOD.  
- * 
- * The class needs the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
- * containing the histograms generated by AliForwardMultiplicity and 
- * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
- * with AliAODEvent objects where AliAODForwardMult objects have been 
- * added to in the branch <tt>Forward</tt>
- * 
- * @ingroup pwg2_forward_analysis_scripts
- */
-class DrawRes1D : public DrawResBase
-{
-public:
-  /** 
-   * Constructor 
-   * 
-   * @param special If true, add to the list of 'specials'
-   */
-  DrawRes1D()
-    : fTotal1D(0)
-  {}
-  //__________________________________________________________________
-  virtual void Clear(Option_t* option) 
-  {
-    DrawResBase::Clear(option);
-    if (fTotal1D) delete fTotal1D;
-    fTotal1D = 0;
-  }
-  //__________________________________________________________________
-  virtual Bool_t IsInit() const { return fTotal1D; }
-  //__________________________________________________________________
-  /** 
-   * Utility function to set-up histograms based on the input 
-   * @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram.   This member function 
-   * is called on the first event so that we have the proper binning 
-   * 
-   * @param templ Input histogram
-   * 
-   * @return true on succcess
-   */
-  virtual Bool_t FirstEvent(const TH2D& templ) 
-  { 
-    if (!DrawResBase::FirstEvent(templ)) return kFALSE;
-    const TAxis* etaAxis = templ.GetXaxis();
-    
-    // Generate sum histograms. 
-    // - fTotal1D will be the sum of projections on the X axis of the input  
-    //   histograms 
-    fTotal1D = new TH1D("dndeta", 
-                       "#frac{1}{N}#frac{dN_{ch}}{d#eta}",
-                       etaAxis->GetNbins(),
-                       etaAxis->GetXmin(),
-                       etaAxis->GetXmax());
-    fTotal1D->SetMarkerStyle(29);
-    fTotal1D->SetMarkerSize(1);
-    fTotal1D->SetStats(0);
-    fTotal1D->SetDirectory(0);
-    fTotal1D->Sumw2();
-
-    return kTRUE;
-  }
-
-
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  virtual void AddContrib(const TH2D& hist, Int_t) 
-  {
-    // Make a projection on the X axis of the input histogram 
-    TH1D*    proj  = hist.ProjectionX("_px", 0, -1, "e");
-    
-    // Add to 1D summed histogram
-    fTotal1D->Add(proj); // , scale);
-    
-    // Remove the projection 
-    delete proj;
-  }
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  virtual TH1D* GetResult() 
-  {
-    // Scale our direct sum of the projects of the input histograms to 
-    // the number of vertex bins and the bin width. If we do rebinning, 
-    // we must scale it one more time.
-    // fTotal1D->Scale(1. / fNAccepted, "width");
-    fTotal1D->Divide(fNorm);
-    fTotal1D->Scale(1., "width");
-    return fTotal1D;
-  }
-  /** 
-   * Browse this object 
-   * 
-   * @param b Browser to use 
-   */
-  virtual void Browse(TBrowser* b) 
-  {
-    if (fTotal1D) b->Add(fTotal1D);
-    DrawResBase::Browse(b);
-  }
-  /** 
-   * Create a new object of this class, and add it to the list of 
-   * specials, and create a browse and browse to this object 
-   * 
-   * @return Newly created object
-   */
-  static DrawRes1D* Create() 
-  {
-    DrawRes1D* dr = new DrawRes1D;
-    gROOT->GetListOfSpecials()->Add(dr);
-    TBrowser* b = new TBrowser("b");
-    b->BrowseObject(gROOT->GetListOfSpecials());
-    return dr;
-  }
-protected:
-  TH1D*              fTotal1D;   // Direct sum of input histograms
-
-  ClassDef(DrawRes1D,0)
-};
-
-//
-// EOF
-//
diff --git a/PWG2/FORWARD/analysis2/older/DrawRes2D.C b/PWG2/FORWARD/analysis2/older/DrawRes2D.C
deleted file mode 100644 (file)
index 2f09d80..0000000
+++ /dev/null
@@ -1,141 +0,0 @@
-#include "DrawResBase.h"
-
-/** 
- * @defgroup pwg2_forward_analysis_scripts PWG2 Forward analysis - scripts
- *
- * @ingroup pwg2_forward_analysis
- */
-/** 
- * Example macro to loop over the event-by-event 2D histogram of 
- * @f[
- *   \frac{d^{2}N_{ch}}{d\eta\,d\phi}
- * @f]
- * stored in an AOD.  
- * 
- * The class needs the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
- * containing the histograms generated by AliForwardMultiplicity and 
- * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
- * with AliAODEvent objects where AliAODForwardMult objects have been 
- * added to in the branch <tt>Forward</tt>
- * 
- * @ingroup pwg2_forward_analysis_scripts
- */
-class DrawRes2D : public DrawResBase
-{
-public:
-  /** 
-   * Constructor 
-   * 
-   * @param special If true, add to the list of 'specials'
-   */
-  DrawRes2D()
-    : fTotal2D(0)
-  {
-  }
-  //__________________________________________________________________
-  virtual void Clear(Option_t* option) 
-  {
-    DrawResBase::Clear(option);
-    if (fTotal2D) delete fTotal2D;
-    fTotal2D = 0;
-  }
-  //__________________________________________________________________
-  Bool_t IsInit() const { return fTotal2D; }
-  //__________________________________________________________________
-  /** 
-   * Utility function to set-up histograms based on the input 
-   * @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram.   This member function 
-   * is called on the first event so that we have the proper binning 
-   * 
-   * @param templ Input histogram
-   * 
-   * @return true on succcess
-   */
-  Bool_t FirstEvent(const TH2D& templ) 
-  { 
-    if (!DrawResBase::FirstEvent(templ)) return kFALSE;
-
-    const TAxis* etaAxis = templ.GetXaxis();
-    const TAxis* phiAxis = templ.GetYaxis();
-    
-    // Generate sum histograms. 
-    // - fTotal2D will be the direct sum of the input histograms. 
-    fTotal2D = new TH2D("d2ndetadphi", "1/N dN^{2}_{ch}/d#etad#phi", 
-                       etaAxis->GetNbins(),
-                       etaAxis->GetXmin(),
-                       etaAxis->GetXmax(),
-                       phiAxis->GetNbins(),
-                       phiAxis->GetXmin(),
-                       phiAxis->GetXmax());
-    fTotal2D->SetXTitle("#eta");
-    fTotal2D->SetYTitle("#varphi [radians]");
-    fTotal2D->SetZTitle(fTotal2D->GetTitle());
-    fTotal2D->Sumw2();
-    fTotal2D->SetStats(0);
-    fTotal2D->SetDirectory(0);
-
-    return kTRUE;
-  }
-
-
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  void AddContrib(const TH2D& hist, Int_t) 
-  {
-    fTotal2D->Add(&hist);
-  }
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  TH1D* GetResult()
-  {
-    // Do not sum underflow bins!
-    TH1D* proj = fTotal2D->ProjectionX("dndeta_proj", 1, -1, "e");
-    TH1D* norm = fTotal2D->ProjectionX("norm", 0, 1, "");
-    proj->SetTitle("1/N dN_{ch}/d#eta");
-    proj->Divide(norm);
-    proj->Scale(1., "width");
-    return proj;
-  }
-  /** 
-   * Browse this object 
-   * 
-   * @param b Browser to use 
-   */
-  void Browse(TBrowser* b) 
-  {
-    if (fTotal2D) b->Add(fTotal2D);
-    DrawResBase::Browse(b);
-  }
-  /** 
-   * Create a new object of this class, and add it to the list of 
-   * specials, and create a browse and browse to this object 
-   * 
-   * @return Newly created object
-   */
-  static DrawResBase* Create() 
-  {
-    DrawRes2D* dr = new DrawRes2D;
-    gROOT->GetListOfSpecials()->Add(dr);
-    TBrowser* b = new TBrowser("b");
-    b->BrowseObject(gROOT->GetListOfSpecials());
-    return dr;
-  }
-protected:
-  TH2D*              fTotal2D;   // Direct sum of input histograms
-
-  ClassDef(DrawRes2D,0)
-};
-
-//
-// EOF
-//
diff --git a/PWG2/FORWARD/analysis2/older/DrawResBase.h b/PWG2/FORWARD/analysis2/older/DrawResBase.h
deleted file mode 100644 (file)
index 39c599a..0000000
+++ /dev/null
@@ -1,764 +0,0 @@
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TBrowser.h>
-#include <TROOT.h>
-#include <TH1I.h>
-#include <TProfile.h>
-#include <TList.h>
-#include <TAxis.h>
-#include <TCanvas.h>
-#include <TPad.h>
-#include <TFile.h>
-#include <TTree.h>
-#include <TError.h>
-#include <TStyle.h>
-#include <THStack.h>
-#include <TLegend.h>
-#include <TMath.h>
-#include <TParameter.h>
-#include "AliAODForwardMult.h"
-
-/** 
- * @defgroup pwg2_forward_analysis_scripts PWG2 Forward analysis - scripts
- *
- * @ingroup pwg2_forward_analysis
- */
-/** 
- * Example macro to loop over the event-by-event 2D histogram of 
- * @f[
- *   \frac{d^{2}N_{ch}}{d\eta\,d\phi}
- * @f]
- * stored in an AOD.  
- * 
- * The class needs the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
- * containing the histograms generated by AliForwardMultiplicity and 
- * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
- * with AliAODEvent objects where AliAODForwardMult objects have been 
- * added to in the branch <tt>Forward</tt>
- * 
- * @ingroup pwg2_forward_analysis_scripts
- */
-class DrawResBase : public TObject 
-{
-public:
-  /** 
-   * Constructor 
-   * 
-   * @param special If true, add to the list of 'specials'
-   */
-  DrawResBase()
-    : fBinVzMin(0),
-      fBinVzMax(0), 
-      fTree(0), 
-      fAOD(0),
-      fNorm(0),
-      fNorm2(0),
-      fVtx(0),
-      fNAccepted(0),
-      fNTriggered(0), 
-      fOut(0),
-      fEtaNorms(),
-      fDirect(0)
-  {
-  }
-  virtual ~DrawResBase() 
-  {
-    Clear();
-  }
-  /** 
-   * Clear internal structures 
-   * 
-   */  
-  virtual void Clear(Option_t* ="") 
-  {
-    // Clear previously created data objects 
-    if (fTree && fTree->GetCurrentFile()) { 
-      fTree->GetCurrentFile()->Close();
-      delete fTree;
-    }
-    if (fOut) {
-      fOut->Close();
-      delete fOut;
-    }
-
-    if (fAOD)     delete fAOD;
-    if (fNorm)    delete fNorm;
-    if (fNorm2)   delete fNorm2;
-    if (fVtx)     delete fVtx;
-    fTree    = 0;
-    fAOD     = 0;
-    fNorm    = 0;
-    fNorm2   = 0;
-    fVtx     = 0;
-    fOut     = 0;
-
-    fEtaNorms.Clear();
-    fNAccepted  = 0;
-    fNTriggered = 0;
-  }
-  //__________________________________________________________________
-  /** 
-   * Open the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
-   * containing the histograms generated by AliForwardMultiplicity and 
-   * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
-   * with AliAODEvent objects.
-   * 
-   * @param base  Base name of files 
-   * @param vzMin Minimum collision vertex z position to use
-   * @param vzMax Maximum collision vertex z position to use
-   * @param rebin Rebinning factor 
-   * 
-   * @return true on success, false otherwise 
-   */
-  virtual Bool_t Open(const char* base, 
-                     Double_t    vzMin=-10, 
-                     Double_t    vzMax=10,
-                     Bool_t      getOld=false)
-  {
-    // Set our cuts etc. 
-    Double_t tVzMin = vzMin;
-    Double_t tVzMax = vzMax;
-    if (tVzMax < tVzMin && tVzMin < 0) tVzMax = -tVzMin;
-
-    // Clear previously created data objects 
-    Clear();
-
-    // Open the AOD file 
-    TString fn   = TString::Format("%s_aods.root", base);
-    TFile*  file = TFile::Open(fn.Data(), "READ");
-    if (!file) { 
-      Error("Init", "Couldn't open %s", fn.Data());
-      return kFALSE;
-    }
-
-    // Get the AOD tree 
-    fTree = static_cast<TTree*>(file->Get("aodTree"));
-    if (!fTree) {
-      Error("Init", "Couldn't get the tree");
-      return kFALSE;
-    }
-
-    // Set the branch pointer 
-    fTree->SetBranchAddress("Forward", &fAOD);
-    
-    // Open the histogram file 
-    fn   = TString::Format("%s_hists.root", base);
-    if (!ReadAuxObjects(fn.Data(), tVzMin, tVzMax, getOld)) { 
-      Error("Init", "Failed to read auxillary objects from %s", fn.Data());
-      return kFALSE;
-    }
-
-    // Open the output file 
-    fn   = TString::Format("%s_out.root", base);
-    fOut = TFile::Open(fn.Data(), "RECREATE");
-    if (!fOut) { 
-      Error("Init", "Couldn't open %s", fn.Data());
-      return kFALSE;
-    }
-    
-    Info("Open", "Selected vertex bins are [%d,%d]", fBinVzMin, fBinVzMax);
-    
-    return kTRUE;
-  }
-  /** 
-   * Read in auxillary objects from file, and initialise the acceptance 
-   * histograms, and find the vertex bins to use. 
-   * 
-   * This member function expects the following structure in the file 
-   *
-   *    PWG2forwardDnDeta              TDirectory
-   *     +- Forward                    TList   
-   *         +- nEventsTrVtx           TH1I
-   *         +- fmdHistCollector       TList
-   *             +- vtxbin00           TList
-   *             |   +- etaAcceptance  TH1F
-   *             +- vtxbin01           TList
-   *             |   +- etaAcceptance  TH1F
-   *             |...
-   *
-   * where nEventsTrVtx has nVtx bins, and the subscript on the vtxbin
-   * lists run from 0 to nVtx-1.  
-   * 
-   * - nEventsTrVtx is a 1D histogram of events per vertex bin.  It is
-   *   only used to find the minimum and the maximum vertex bins to
-   *   use. 
-   * - The etaAcceptance histograms are 1D histograms of the covered
-   *   eta bins for each vertex bin.
-   *
-   * A file with the correct output is normally generated when
-   * executing the AliForwardMultiplicity task, but can also be
-   * generated outside of that analysis task.  In that case, one has
-   * to be certain, that the secondary map cuts used are the same, and
-   * that the vertex bins are the same as used in the analysis. 
-   * 
-   * @param filename   File to read from 
-   * @param vzMin      Least vertex Z coordinate to accept
-   * @param vzMax      Most vertex Z coordinate to accept
-   * 
-   * @return true on succes, error otherwise 
-   */
-  virtual Bool_t ReadAuxObjects(const char* filename,
-                               Double_t vzMin, 
-                               Double_t vzMax, 
-                               Bool_t   getOld) 
-  { 
-    TFile* file = TFile::Open(filename, "READ");
-    if (!file) { 
-      Error("Init", "Couldn't open %s", filename);
-      return kFALSE;
-    }
-    
-    // Get the list stored in the file 
-    TList* forward = 
-      static_cast<TList*>(file->Get("PWG2forwardDnDeta/Forward"));
-    if (!forward)  {
-      Error("ReadAuxObjects", "Couldn't get forward list");
-      return kFALSE;
-    }
-
-    // Get the list from the collector 
-    TList* collect = 
-      static_cast<TList*>(forward->FindObject("fmdHistCollector"));
-    if (!collect)  {
-      Error("Init", "Couldn't get collector list");
-      return kFALSE;
-    }
-
-    // Get the event (by vertex bin) histogram 
-    TH1* events = static_cast<TH1I*>(forward->FindObject("nEventsTrVtx"));
-    if (!events) {
-      Error("ReadAuxObjects", "Couldn't get the event histogram");
-      return kFALSE;
-    }
-    // Find the min/max bins to use based on the cuts given 
-    fBinVzMin = events->FindBin(vzMin);
-    fBinVzMax = events->FindBin(vzMax-.0000001);
-
-    // Make the normalisation 
-    for (Int_t iVz = fBinVzMin; iVz <= fBinVzMax; iVz++) { 
-
-      // Get the acceptance from the input file 
-      TList* l = static_cast<TList*>(collect
-                                    ->FindObject(Form("vtxbin%02d",iVz-1)));
-      if (!l) { 
-       Error("ReadAuxObjets", "List vtxbin%02d not found in %s", 
-             iVz-1, collect->GetName());
-       continue;
-      }
-      TH1F* ve = static_cast<TH1F*>(l->FindObject("etaAcceptance"));
-      if (!ve){ 
-       Error("ReadAuxObjects", "No eta acceptance histogram found in  "
-             "vtxbin%02d/etaAcceptance", iVz-1);
-       continue;
-      }
-      TH1F* te = static_cast<TH1F*>(ve->Clone(Form("etaAcceptance%0d",iVz)));
-      te->SetDirectory(0);
-      fEtaNorms.AddAtAndExpand(te, iVz);
-    }
-    fEtaNorms.SetOwner(kTRUE);
-
-    Bool_t ret = ReadMoreAuxObjects(file,forward,collect,getOld);
-    file->Close();
-    return ret;
-  }
-  //__________________________________________________________________
-  virtual Bool_t ReadMoreAuxObjects(TFile* file, 
-                                   TList* forward, 
-                                   TList* collect, 
-                                   Bool_t getOld)
-  {
-    if (getOld) { 
-      fDirect = static_cast<TH1D*>(collect->FindObject("dndeta"));
-      if (fDirect) {
-       fDirect->SetTitle(Form("%s directly", fDirect->GetTitle()));
-       fDirect->SetLineColor(kBlue+1);
-       fDirect->SetMarkerColor(kBlue+1);
-       fDirect->SetMarkerStyle(21);
-       fDirect->SetMarkerSize(0.8);
-      }
-      else 
-       Warning("Finish", "Couldn't get the old dN/deta histogram");
-    }
-
-    return kTRUE;
-  }
-  //__________________________________________________________________
-  /** 
-   * Check if the passed vertex bin number [1,nVtxBins] is within our 
-   * cut. 
-   * 
-   * @param bin Vertex bin [1,nVtxBins] 
-   * 
-   * @return true if within cut, false otherwise 
-   */
-  Bool_t IsInsideVtxCut(Int_t bin) const 
-  {
-    return bin >= fBinVzMin && bin <= fBinVzMax;
-  }
-  virtual Bool_t IsInit() const = 0;
-  //__________________________________________________________________
-  /** 
-   * Utility function to set-up histograms based on the input 
-   * @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram.   This member function 
-   * is called on the first event so that we have the proper binning 
-   * 
-   * @param templ Input histogram
-   * 
-   * @return true on succcess
-   */
-  virtual Bool_t FirstEvent(const TH2D& templ) 
-  { 
-    Info("FirstEvent", "Generating histograms");
-
-    const TAxis* etaAxis = templ.GetXaxis();
-    // - fNorm is the normalisation 
-    fNorm = new TH1D("norm", "Normalisation", 
-                    etaAxis->GetNbins(),
-                    etaAxis->GetXmin(),
-                    etaAxis->GetXmax());
-    fNorm->SetFillColor(kRed);
-    fNorm->SetFillStyle(3001);
-    fNorm->SetXTitle("#eta");
-    fNorm->SetYTitle("Normalisation");
-    fNorm->SetStats(0);
-    fNorm->SetDirectory(0);
-
-    fNorm2 = new TH1D("norm2", "Normalisation", 
-                     etaAxis->GetNbins(),
-                     etaAxis->GetXmin(),
-                     etaAxis->GetXmax());
-    fNorm2->SetFillColor(kBlue);
-    fNorm2->SetFillStyle(3003);
-    fNorm2->SetXTitle("#eta");
-    fNorm2->SetYTitle("Normalisation");
-    fNorm2->SetStats(0);
-    fNorm2->SetDirectory(0);
-
-    // - fVtx is the vertex distribution 
-    fVtx = new TH1D("vtx", "Events per vertex bin", 
-                   fBinVzMax-fBinVzMin+1, 
-                   fBinVzMin, fBinVzMax);
-    fVtx->SetXTitle("v_{z} bin");
-    fVtx->SetYTitle("Events");
-    fVtx->SetDirectory(0);
-    fVtx->SetFillColor(kRed+1);
-    fVtx->SetFillStyle(3001);
-    fVtx->SetStats(0);
-    
-    return kTRUE;
-  }
-
-
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  virtual Bool_t Process() 
-  {
-    // Get the number of events in the tree 
-    Int_t nEntries  = fTree->GetEntries();
-    
-    // Loop over the events in the tree 
-    for (Int_t event = 0; event < nEntries; event++) { 
-      fTree->GetEntry(event);
-      if ((event+1) % 1000 == 0) 
-       Info("Process", "Event # %6d of %d", event+1, nEntries);
-      
-      // Get our input histogram 
-      const TH2D& hist = fAOD->GetHistogram();
-
-      
-      // If fTotal2D is not made yet, do so (first event)
-      if (!IsInit()) { 
-       if (!FirstEvent(hist)) { 
-         Error("Process", "Failed to initialize on first event");
-         return kFALSE;
-       }
-      }
-      
-      // Check the trigger 
-      if (!fAOD->IsTriggerBits(AliAODForwardMult::kInel)) { 
-       // Info("Process", "Not an INEL event");
-       continue;
-      }
-      fNTriggered++;
-
-      // Get the vertex bin - add 1 as we are using histogram bin 
-      // numbers in this class 
-      Int_t vtxBin = fAOD->GetVtxBin()+1;
-      
-      // Check if we're within vertex cut
-      if (!IsInsideVtxCut(vtxBin)) continue;
-
-      // Increment our vertex event and total accepted counters 
-      fVtx->AddBinContent(vtxBin);
-      fNAccepted++;
-
-      for (Int_t iEta = 1; iEta <= hist.GetNbinsX(); iEta++) 
-       if (hist.GetBinContent(iEta,0)) 
-         fNorm2->AddBinContent(iEta);
-
-      AddContrib(hist, vtxBin);
-    }
-    FindNormalization();
-
-    Info("Process", "Got %6d trigger, and accepted %6d out of %6d events", 
-        fNTriggered, fNAccepted, nEntries);
-
-    return kTRUE;
-  }
-  //__________________________________________________________________
-  /** 
-   * Normalize the result 
-   * 
-   */
-  void FindNormalization()
-  {
-    fEtaNorms.ls();
-    // Make the normalisation 
-    for (Int_t iVz = fBinVzMin; iVz <= fBinVzMax; iVz++) { 
-
-      // Get the acceptance from the input file 
-      TH1F* ve = static_cast<TH1F*>(fEtaNorms.At(iVz));
-      if (!ve){ 
-       Error("FindNormalization", 
-             "No eta acceptance histogram found for vertex bin %d", iVz);
-       continue;
-      }
-      // Add the vertex-dependent acceptance weighted by the number 
-      // of events in this vertex bin 
-      fNorm->Add(ve, fVtx->GetBinContent(iVz));
-    }
-    // Set all errors to zero (not used)
-    for (Int_t i = 1; i <= fNorm->GetNbinsX(); i++) {
-      fNorm->SetBinError(i, 0);
-      fNorm2->SetBinError(i, 0);
-    }
-  } 
-  //__________________________________________________________________
-  /** 
-   * Add a contribtion from @a hist to result
-   * 
-   * @param hist   Contribution to add 
-   * @param vtxBin Vertex bin. 
-   */
-  virtual void AddContrib(const TH2D& hist, Int_t vtxBin) = 0;
-
-  //__________________________________________________________________
-  /** 
-   * Called at the end of the job. 
-   *
-   * It plots the result of the analysis in tree canvases.   
-   * - One shows the per-vertex accumalted histograms and compares them 
-   *   to the per-vertex histograms made in the analysis. 
-   * - Another shows the final @f$ dN_{ch}/d\eta@f$ calculated in 
-   *   different ways and compare those to the  @f$ dN_{ch}/d\eta@f$ made 
-   *   during the analysis. 
-   * - The last canvas shows the @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram. 
-   * 
-   * @return true on succes, false otherwise 
-   */
-  Bool_t Finish(Int_t rebin) 
-  {
-    // Set the style 
-    gStyle->SetOptTitle(0);
-    gStyle->SetPadColor(0);
-    gStyle->SetPadBorderSize(0);
-    gStyle->SetPadBorderMode(0);
-    gStyle->SetPadRightMargin(0.05);
-    gStyle->SetPadTopMargin(0.05);
-    gStyle->SetPalette(1);
-
-    // Make a stack to 'auto-scale' when plotting more than 1 histogram.
-    THStack* stack = new THStack("results","Results for #frac{dN_{ch}}{d#eta}");
-
-    // Generate the projection from the direct sum of the input histograms, 
-    // and scale it to the number of vertex bins and the bin width 
-    TH1D* tmp = fNorm;
-    fNorm = fNorm2;
-    fNorm2 = tmp;
-    TH1D* h = GetResult();
-    h->SetMarkerColor(kRed+1);
-    h->SetMarkerStyle(20);
-    h->SetMarkerSize(1);
-    h->Scale(Float_t(fNAccepted)/fNTriggered);
-    TH1D* s = Symmetrice(h);
-    Rebin(h, rebin);
-    Rebin(s, rebin);
-    stack->Add(h);
-    stack->Add(s);
-    
-    // Get the result from the analysis and plit that too (after modifying 
-    // the style and possible rebinning)
-    Float_t y1 = 0;
-    if (fDirect) {
-      fDirect->Scale(Float_t(fNAccepted)/fNTriggered);
-      Rebin(fDirect, rebin);
-      stack->Add(fDirect, "");
-      y1 = 0.3;
-    }
-
-    // The second canvas 
-    TCanvas* cTotal1D =  new TCanvas("total", "Result", 800, 800);
-    cTotal1D->SetFillColor(0);
-    cTotal1D->SetBorderMode(0);
-    cTotal1D->SetBorderSize(0);
-    cTotal1D->cd();
-
-    // Draw stack in pad
-    TPad* p1 = new TPad("p1", "p1", 0, y1, 1.0, 1.0, 0, 0);
-    p1->Draw();
-    p1->cd();
-    stack->DrawClone("nostack e1 p");
-    stack->Write();
-
-    // Make a legend 
-    TLegend* l = p1->BuildLegend(0.31, 0.15, 0.5, 0.6);
-    l->SetFillColor(0);
-    l->SetBorderSize(0);
-    l->SetTextSize(0.04); // l->GetTextSize()/3);
-    cTotal1D->cd();
-
-    if (fDirect) { 
-      // Create a new stack 
-      stack = new THStack("ratios", "Ratios to old method");
-      
-      // Calculate the ratio of our direct sum of input histograms 
-      // result from the analysis  and draw it 
-      TH1D* ratio = static_cast<TH1D*>(h->Clone("ratio"));
-      ratio->SetDirectory(0);
-      ratio->Divide(fDirect);
-      TH1* z = Symmetrice(ratio);
-      stack->Add(ratio, "");
-      stack->Add(z,     "");
-    
-      // Generate our second pad and draw
-      TPad* p2 = new TPad("p2", "p2", 0, 0.0, 1.0, y1, 0, 0);
-      p2->Draw();
-      p2->cd();
-      stack->Draw("nostack e1");
-      stack->DrawClone("nostack e1");
-      stack->Write();
-    }
-
-    // update 
-    cTotal1D->cd();
-
-    // Generate the last canvas and show the summed input histogram 
-    TCanvas* other = new TCanvas("other", "Other", 800, 600);
-    other->SetFillColor(0);
-    other->SetBorderMode(0);
-    other->SetBorderSize(0);
-    other->Divide(2,1);
-
-    other->cd(1);
-    fNorm->DrawCopy("HIST");
-    fNorm->Write();
-    
-    other->cd(2);
-    fNorm2->DrawCopy("HIST");
-    fNorm2->Write();
-    // fVtx->DrawCopy();
-    // fVtx->Write();
-
-    // out->Write();
-    fOut->Close();
-    return kTRUE;
-  }
-  //__________________________________________________________________
-  /** 
-   * Get the result 
-   * 
-   * @return The result 
-   */
-  virtual TH1D* GetResult() { return 0; }
-
-  //__________________________________________________________________
-  /** 
-   * Rebin a histogram 
-   * 
-   * @param h     Histogram to rebin
-   * @param rebin Rebinning factor 
-   * 
-   * @return 
-   */
-  virtual void Rebin(TH1D* h, Int_t rebin) const
-  { 
-    if (rebin <= 1) return;
-
-    Int_t nBins = h->GetNbinsX();
-    if(nBins % rebin != 0) {
-      Warning("Rebin", "Rebin factor %d is not a devisor of current number "
-             "of bins %d in the histogram %s", rebin, nBins, h->GetName());
-      return;
-    }
-    if (h->IsA()->InheritsFrom(TProfile::Class())){
-      h->Rebin(rebin);
-      return;
-    }
-      
-    
-    // Make a copy 
-    TH1D* tmp = static_cast<TH1D*>(h->Clone("tmp"));
-    tmp->Rebin(rebin);
-    tmp->SetDirectory(0);
-
-    // The new number of bins 
-    Int_t nBinsNew = nBins / rebin;
-    for(Int_t i = 1;i<= nBinsNew; i++) {
-      Double_t content = 0;
-      Double_t sumw    = 0;
-      Double_t wsum    = 0;
-      Int_t    nbins   = 0;
-      for(Int_t j = 1; j<=rebin;j++) {
-       Int_t bin = (i-1)*rebin + j;
-       if(h->GetBinContent(bin) <= 0) continue;
-       Double_t c =  h->GetBinContent(bin);
-       Double_t w = 1 / TMath::Power(c,2);
-       content    += c;
-       sumw       += w;
-       wsum       += w * c;
-       nbins++;
-      }
-      
-      if(content > 0 ) {
-       tmp->SetBinContent(i, wsum / sumw);
-       tmp->SetBinError(i,TMath::Sqrt(sumw));
-      }
-    }
-
-    // Finally, rebin the histogram, and set new content
-    h->Rebin(rebin);
-    for(Int_t i =1;i<=nBinsNew; i++) {
-      h->SetBinContent(i,tmp->GetBinContent(i));
-      // h->SetBinError(i,tmp->GetBinError(i));
-    }
-
-    delete tmp;
-  }
-  //__________________________________________________________________
-  TH1D* Symmetrice(const TH1D* h) const
-  {
-    Int_t nBins = h->GetNbinsX();
-    TH1D* s     = new TH1D(Form("%s_mirror", h->GetName()),
-                          Form("%s (mirrored)", h->GetTitle()), 
-                          nBins, 
-                          -h->GetXaxis()->GetXmax(), 
-                          -h->GetXaxis()->GetXmin());
-    s->SetDirectory(0);
-    s->SetMarkerColor(h->GetMarkerColor());
-    s->SetMarkerSize(h->GetMarkerSize());
-    s->SetMarkerStyle(h->GetMarkerStyle()+4);
-
-    // Find the first and last bin with data 
-    Int_t first = nBins+1;
-    Int_t last  = 0;
-    for (Int_t i = 1; i <= nBins; i++) { 
-      if (h->GetBinContent(i) <= 0) continue; 
-      first = TMath::Min(first, i);
-      last  = TMath::Max(last,  i);
-    }
-    
-    Double_t xfirst = h->GetBinCenter(first-1);
-    Double_t xlast  = h->GetBinCenter(last);
-    Int_t    f1     = h->GetXaxis()->FindBin(-xfirst);
-    Int_t    f2     = s->GetXaxis()->FindBin(-xlast);
-    Int_t    l2     = s->GetXaxis()->FindBin(xfirst);
-    Info("Symmetrice", "Data in [%d,%d], copying data from [%d,%d] to [%d,%d]", 
-        first, last, f1, last, f2, l2);
-    for (Int_t i = f1, j=l2; i <= last; i++,j--) { 
-      s->SetBinContent(j, h->GetBinContent(i));
-      s->SetBinError(j, h->GetBinError(i));
-    }
-    return s;
-  }
-    
-
-  //__________________________________________________________________
-  /** 
-   * Run the post-processing.  
-   * 
-   * This will open the files &lt;<i>base</i>&gt;<tt>_hists.root</tt>
-   * containing the histograms generated by AliForwardMultiplicity and
-   * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the
-   * tree with AliAODEvent objects. 
-   *
-   * Then it will loop over the events, accepting only INEL events
-   * that have a primary collision point along z within @a vzMin and
-   * @a vzMax.
-   *
-   * After the processing, the result will be shown in 3 canvases, 
-   * possibly  rebinning the result by the factor @a rebin. 
-   * 
-   * @param base  Base name of files 
-   * @param vzMin Minimum collision vertex z position to use
-   * @param vzMax Maximum collision vertex z position to use
-   * @param rebin Rebinning factor 
-   * 
-   * @return true on success, false otherwise 
-   */
-  Bool_t Run(const char* base, 
-            Double_t vzMin=-10,  
-            Double_t vzMax=10, 
-            Int_t rebin=1,
-            Bool_t getOld=false) 
-  {
-    if (!Open(base,vzMin,vzMax,getOld)) return kFALSE;
-    if (!Process())                     return kFALSE;
-    if (!Finish(rebin))                 return kFALSE;
-
-    return kTRUE;
-  } // *MENU*
-  /** 
-   * Get name of object
-   * 
-   * @return Object name 
-   */
-  const char* GetName() const { return "drawRes"; }
-  /** 
-   * This is a folder
-   *
-   * @return always true 
-   */
-  Bool_t IsFolder() const { return kTRUE; }
-  /** 
-   * Browse this object 
-   * 
-   * @param b Browser to use 
-   */
-  virtual void Browse(TBrowser* b) 
-  {
-    b->Add(&fEtaNorms, "#eta Acceptances");
-    if (fTree)    b->Add(fTree);
-    if (fNorm)    b->Add(fNorm);
-    if (fNorm2)   b->Add(fNorm2);
-    if (fVtx)     b->Add(fVtx);
-    if (fDirect)  b->Add(fDirect);
-    b->Add(new TParameter<Int_t>   ("binVzMin",    fBinVzMin));
-    b->Add(new TParameter<Int_t>   ("binVzMax",    fBinVzMax));
-    b->Add(new TParameter<Int_t>   ("fNAccepted",  fNAccepted));
-    b->Add(new TParameter<Int_t>   ("fNTriggered", fNTriggered));
-  }
-protected:
-  Int_t              fBinVzMin;  // Corresponding bin to min vertex
-  Int_t              fBinVzMax;  // Corresponding bin to max vertex
-  TTree*             fTree;      // Event tree 
-  AliAODForwardMult* fAOD;       // Our event-by-event data
-  TH1D*              fNorm;      // Histogram of # events with data per bin 
-  TH1D*              fNorm2;      // Histogram of # events with data per bin 
-  TH1D*              fVtx;       // Histogram of # events with data per bin 
-  Int_t              fNAccepted; // # of accepted events with vertex 
-  Int_t              fNTriggered;// # of events with trigger 
-  TFile*             fOut;       // Output file 
-  TObjArray          fEtaNorms;  // Array of eta acceptances per vertex 
-  TH1D*              fDirect;
-
-  ClassDef(DrawResBase,0)
-};
-
-// Local Variables: 
-//  mode: C++
-// End:
diff --git a/PWG2/FORWARD/analysis2/older/DrawResKeep.C b/PWG2/FORWARD/analysis2/older/DrawResKeep.C
deleted file mode 100644 (file)
index 5d58065..0000000
+++ /dev/null
@@ -1,754 +0,0 @@
-#include <TH1D.h>
-#include <TH2D.h>
-#include <TH1I.h>
-#include <TProfile.h>
-#include <TList.h>
-#include <TAxis.h>
-#include <TCanvas.h>
-#include <TPad.h>
-#include <TFile.h>
-#include <TTree.h>
-#include <TError.h>
-#include <TStyle.h>
-#include <THStack.h>
-#include <TLegend.h>
-#include <TMath.h>
-#include "AliAODForwardMult.h"
-
-/** 
- * @defgroup pwg2_forward_analysis_scripts PWG2 Forward analysis - scripts
- *
- * @ingroup pwg2_forward_analysis
- */
-/** 
- * Example macro to loop over the event-by-event 2D histogram of 
- * @f[
- *   \frac{d^{2}N_{ch}}{d\eta\,d\phi}
- * @f]
- * stored in an AOD.  
- * 
- * The class needs the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
- * containing the histograms generated by AliForwardMultiplicity and 
- * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
- * with AliAODEvent objects where AliAODForwardMult objects have been 
- * added to in the branch <tt>Forward</tt>
- * 
- * @ingroup pwg2_forward_analysis_scripts
- */
-class DrawRes 
-{
-public:
-  /** 
-   * Constructor 
-   * 
-   * @param special If true, add to the list of 'specials'
-   */
-  DrawRes(Bool_t special=true)
-    : fVzMin(-10), 
-      fVzMax(10), 
-      fBinVzMin(0),
-      fBinVzMax(0), 
-      fRebin(1),
-      fTree(0), 
-      fAOD(0),
-      fEvents(0), 
-      fCollect(0),
-      fByVtx1D(0),
-      fTotal1D(0), 
-      fTotal2D(0),
-      fFromVtx(0),
-      fNorm(0)
-  {}
-  //__________________________________________________________________
-  /** 
-   * Open the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
-   * containing the histograms generated by AliForwardMultiplicity and 
-   * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
-   * with AliAODEvent objects.
-   * 
-   * @param base  Base name of files 
-   * @param vzMin Minimum collision vertex z position to use
-   * @param vzMax Maximum collision vertex z position to use
-   * @param rebin Rebinning factor 
-   * 
-   * @return true on success, false otherwise 
-   */
-  Bool_t Open(const char* base, 
-             Double_t    vzMin=-10, 
-             Double_t    vzMax=10, 
-             Int_t       rebin=1)
-  {
-    // Set our cuts etc. 
-    fVzMin = vzMin;
-    fVzMax = vzMax;
-    if (fVzMax < fVzMin && fVzMin < 0) fVzMax = -fVzMin;
-    fRebin = rebin;
-
-    // Clear previously created data objects 
-    fByVtx1D.Delete();
-    if (fTotal1D) { delete fTotal1D; fTotal1D = 0; }
-    if (fTotal2D) { delete fTotal2D; fTotal2D = 0; }
-    if (fTree && fTree->GetCurrentFile()) { 
-      fTree->GetCurrentFile()->Close();
-    }
-    fCollect = 0;
-    fTree    = 0;
-
-    // Open the AOD file 
-    TString fn   = TString::Format("%s_aods.root", base);
-    TFile*  file = TFile::Open(fn.Data(), "READ");
-    if (!file) { 
-      Error("Init", "Couldn't open %s", fn.Data());
-      return kFALSE;
-    }
-
-    // Get the AOD tree 
-    fTree = static_cast<TTree*>(file->Get("aodTree"));
-    if (!fTree) {
-      Error("Init", "Couldn't get the tree");
-      return kFALSE;
-    }
-
-    // Set the branch pointer 
-    fTree->SetBranchAddress("Forward", &fAOD);
-    
-    // Open the histogram file 
-    fn   = TString::Format("%s_hists.root", base);
-    file = TFile::Open(fn.Data(), "READ");
-    if (!file) { 
-      Error("Init", "Couldn't open %s", fn.Data());
-      return kFALSE;
-    }
-    
-    // Get the list stored in the file 
-    TList* forward = 
-      static_cast<TList*>(file->Get("PWG2forwardDnDeta/Forward"));
-    if (!forward)  {
-      Error("Init", "Couldn't get forward list");
-      return kFALSE;
-    }
-
-    // Get the list from the collector 
-    fCollect = 
-      static_cast<TList*>(forward->FindObject("fmdHistCollector"));
-    if (!fCollect)  {
-      Error("Init", "Couldn't get collector list");
-      return kFALSE;
-    }
-
-    // Get the event (by vertex bin) histogram 
-    fEvents = static_cast<TH1I*>(forward->FindObject("nEventsTrVtx"));
-    if (!fEvents) {
-      Error("Init", "Couldn't get the event histogram");
-      return kFALSE;
-    }
-    
-    // Find the min/max bins to use based on the cuts given 
-    fBinVzMin = fEvents->FindBin(fVzMin);
-    fBinVzMax = fEvents->FindBin(fVzMax-.0000001);
-    Info("Open", "Selected vertex bins are [%d,%d]", fBinVzMin, fBinVzMax);
-    
-    return kTRUE;
-  }
-  //__________________________________________________________________
-  /** 
-   * Check if the passed vertex bin number [1,nVtxBins] is within our 
-   * cut. 
-   * 
-   * @param bin Vertex bin [1,nVtxBins] 
-   * 
-   * @return true if within cut, false otherwise 
-   */
-  Bool_t IsInsideVtxCut(Int_t bin) const 
-  {
-    return bin >= fBinVzMin && bin <= fBinVzMax;
-  }
-
-  //__________________________________________________________________
-  /** 
-   * Make a 1D histogram of @f$ dN_{ch}/d\eta@f$ with the given name and 
-   * title 
-   * 
-   * @param name   Name of histogram 
-   * @param title  Title of histogram 
-   * @param a1     Eta axis 
-   * 
-   * @return Newly allocated 1D histogram object 
-   */
-  TH1D* Make1D(const char* name, const char* title, const TAxis* a1)
-  {
-    TH1D* ret = new TH1D(name, title,
-                        a1->GetNbins(), a1->GetXmin(), a1->GetXmax());
-    ret->SetXTitle("#eta");
-    ret->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
-    ret->Sumw2();
-    ret->SetMarkerColor(kRed+1);
-    ret->SetLineColor(kRed+1);
-    ret->SetMarkerStyle(24);
-    ret->SetMarkerSize(1);
-    ret->SetStats(0);
-    ret->SetDirectory(0);
-
-    return ret;
-  }
-  //__________________________________________________________________
-  /** 
-   * Make a 2D histogram of @f$ d^{2}N_{ch}/d\eta\,d\phi@f$
-   * 
-   * @param name  Name of histogram 
-   * @param title Title of histogram 
-   * @param a1    Eta axis 
-   * @param a2    Phi axis 
-   * 
-   * @return 
-   */
-  TH2D* Make2D(const char* name, const char* title, 
-              const TAxis* a1, const TAxis* a2)
-  {
-    TH2D* ret = new TH2D(name, title,
-                        a1->GetNbins(), a1->GetXmin(), a1->GetXmax(),
-                        a2->GetNbins(), a2->GetXmin(), a2->GetXmax());
-    ret->SetXTitle("#eta");
-    ret->SetYTitle("#varphi");
-    ret->SetZTitle("#frac{1}{N}#frac{dN^{2}_{ch}}{d#etad#varphi}");
-    ret->Sumw2();
-    ret->SetStats(0);
-    ret->SetDirectory(0);
-
-    return ret;
-  }
-  //__________________________________________________________________
-  /** 
-   * Utility function to set-up histograms based on the input 
-   * @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram.   This member function 
-   * is called on the first event so that we have the proper binning 
-   * 
-   * @param templ Input histogram
-   * 
-   * @return true on succcess
-   */
-  Bool_t FirstEvent(const TH2D& templ) 
-  { 
-    const TAxis* etaAxis = templ.GetXaxis();
-    const TAxis* phiAxis = templ.GetYaxis();
-    
-    // Generate sum histograms. 
-    // - fTotal1D will be the sum of projections on the X axis of the input  
-    //   histograms 
-    // - fTotal2D will be the direct sum of the input histograms. 
-    // - fFromVtx will be the sum of the per vertex histograms after 
-    //   processing all events 
-    fTotal1D = Make1D("dndeta", 
-                     "#frac{1}{N}#frac{dN_{ch}}{d#eta} direct sum", etaAxis);
-    fTotal2D = Make2D("d2ndetadphi", 
-                     "#frac{1}{N}#frac{dN^{2}_{ch}}{d#etad#phi} direct sum", 
-                     etaAxis, phiAxis);
-    fFromVtx = Make1D("dndeta_test", "#frac{1}{N}#frac{dN_{ch}}{d#eta} "
-                     "from VTX", etaAxis);
-    fTotal1D->SetMarkerStyle(25);
-    fTotal1D->SetMarkerSize(1.1);
-    fNorm    = new TH1D("norm", "Normalisation", 
-                       etaAxis->GetNbins(),
-                       etaAxis->GetXmin(),
-                       etaAxis->GetXmax());
-    fNorm->SetFillColor(kRed);
-    fNorm->SetFillStyle(3001);
-    fNorm->SetXTitle("#eta");
-    fNorm->SetYTitle("Normalisation");
-    fNorm->Sumw2();
-    fNorm->SetDirectory(0);
-    fVtx     = new TH1D("vtx", "Events per vertex bin", 
-                       fEvents->GetXaxis()->GetNbins(),
-                       fEvents->GetXaxis()->GetXmin(), 
-                       fEvents->GetXaxis()->GetXmax());
-    fVtx->SetXTitle("v_{z} [cm]");
-    fVtx->SetYTitle("Events");
-    fVtx->SetDirectory(0);
-    fVtx->SetFillColor(kRed+1);
-    fVtx->SetFillStyle(3001);
-    
-
-    // Generate the per-vertex bin histograms.  These will be the sum 
-    // of each of the per-event input histograms for a given vertex range. 
-    for (Int_t i = fBinVzMin; i <= fBinVzMax; i++) { 
-      TH1* h1 = Make1D(Form("dndeta_vz%02d", i), 
-                      Form("#frac{1}{N}#frac{dN_{ch}}{d#eta}, vtxbin=%d", i),
-                      etaAxis);
-      fByVtx1D.AddAtAndExpand(h1, i);
-    }
-    return kTRUE;
-  }
-
-
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  Bool_t Process() 
-  {
-    // Get the number of events in the tree 
-    Int_t nEntries  = fTree->GetEntries();
-    fNAccepted = 0;
-    
-    // Loop over the events in the tree 
-    for (Int_t event = 0; event < nEntries; event++) { 
-      fTree->GetEntry(event);
-      
-      // Get our input histogram 
-      const TH2D& hist = fAOD->GetHistogram();
-
-      
-      // If fTotal1D or fTotal2D are not made yet, do so (first event)
-      if (!fTotal2D || !fTotal1D) { 
-       if (!FirstEvent(hist)) { 
-         Error("Process", "Failed to initialize on first event");
-         return kFALSE;
-       }
-      }
-      
-      // Check the trigger 
-      if (!fAOD->IsTriggerBits(AliAODForwardMult::kInel)) { 
-       // Info("Process", "Not an INEL event");
-       continue;
-      }
-
-      // Get the vertex bin - add 1 as we are using histogram bin 
-      // numbers in this class 
-      Int_t vtxBin = fAOD->GetVtxBin()+1;
-      
-      // Check if we're within vertex cut
-      if (!IsInsideVtxCut(vtxBin)) { 
-       Info("Process", "In event # %d, %d not within vertex cut "
-            "[%d,%d] (%f,%f)", 
-            event, vtxBin, fBinVzMin, fBinVzMax, fVzMin, fVzMax);
-       continue;
-      }
-      fVtx->AddBinContent(vtxBin);
-
-      // Increment our accepted counter 
-      fNAccepted++;
-
-      // Get the scale of this vertex range 
-      Double_t vtxScale = fEvents->GetBinContent(vtxBin);
-      
-      // Get 'by-vertex' histograms 
-      TH1* tmp1 = static_cast<TH1D*>(fByVtx1D.At(vtxBin));
-      if (!tmp1) { 
-       Warning("Process", "No histogram for vertex bin %d)",vtxBin);
-       continue;
-      }
-
-      Double_t scale = 1. / vtxScale;
-      if (tmp1->InheritsFrom(TProfile::Class())) 
-       scale = 1;
-
-      if (!AddContrib(hist, *tmp1, scale)) return kFALSE;
-
-    }
-    for (Int_t iVz = fBinVzMin; iVz <= fBinVzMax; iVz++) { 
-      TList* l = static_cast<TList*>(fCollect
-                                    ->FindObject(Form("vtxbin%02d",iVz-1)));
-      if (!l) { 
-       Error("Process", "List vtxbin%02d not found in %s", 
-             iVz-1, fCollect->GetName());
-       continue;
-      }
-      TH1F* ve = static_cast<TH1F*>(l->FindObject("etaAcceptance"));
-      if (!ve){ 
-       Error("Process", "No eta acceptance histogram found in  "
-             "vtxbin%02d/etaAcceptance", iVz-1);
-       continue;
-      }
-      ve->Sumw2();
-      fNorm->Add(ve, fVtx->GetBinContent(iVz));
-    }
-    for (Int_t i = 1; i <= fNorm->GetNbinsX(); i++) 
-      fNorm->SetBinError(i, 0);
-    // fNorm->Scale(1.);
-
-    Info("Process", "Accepted %6d out of %6d events", fNAccepted, nEntries);
-    return kTRUE;
-  } 
-  //__________________________________________________________________
-  Bool_t AddContrib(const TH2D& hist, TH1& vtx1D, Double_t scale)
-  {
-    // Make a projection on the X axis of the input histogram 
-    TH1D*    proj  = hist.ProjectionX("_px", 0, -1, "e");
-    
-    // Add to per-vertex histogram 
-    vtx1D.Add(proj); // , scale);
-
-#if defined(USE_NORM_HIST)
-    scale = 1;
-#endif
-
-#if defined(USE_WEIGHTED_MEAN)
-    Int_t nBinPhi = hist.GetXaxis()->GetNbins();
-    for (Int_t binEta = 1; binEta <= nBinEta; binEta++) { 
-      AddBinContrib(binEta, *proj, *fTotal1D);
-      for (Int_t binPhi = 1; binPhi < nBinPhi; binPhi++) 
-       AddBinContrib(hist.GetBin(binEta, binPhi), hist, *fTotal2D);
-    }
-#else 
-    // Add to 1D summed histogram
-    fTotal1D->Add(proj); // , scale);
-    
-    // Add to 2D summed histogram 
-    fTotal2D->Add(&hist); // , scale);
-#endif 
-    
-    // Remove the projection 
-    delete proj;
-
-    return kTRUE;
-  }
-  //__________________________________________________________________
-  Bool_t AddBinContrib(Int_t bin, const TH1& in, TH1& out) 
-  {
-    Double_t ic = in.GetBinContent(bin);
-    Double_t ie = in.GetBinError(bin);
-    if (ie <= 0.00001) return kTRUE;
-
-    Double_t iw = 1 / (ie*ie);
-    Double_t oc = out.GetBinContent(bin);
-    Double_t oe = out.GetBinError(bin);
-
-    // Store weighted sum in histogram 
-    out.SetBinContent(bin, oc + iw * ic);
-    // Store sum of weights in histogram 
-    out.SetBinError(bin, oe + iw);
-
-    return kTRUE;
-  }    
-  //__________________________________________________________________
-  Bool_t SetResult(TH1*)
-  {
-#if defined(USE_WEIGHTED_MEAN)
-    Double_t scale   = 1.;
-    Int_t    nBinEta = fTotal2D->GetXaxis()->GetNbins();
-    Int_t    nBinPhi = fTotal1D->GetXaxis()->GetNbins();
-    for (Int_t binEta = 1; binEta <= nBinEta; binEta++) { 
-      SetBinResult(binEta, *fTotal1D);
-      for (Int_t binPhi = 1; binPhi < nBinPhi; binPhi++) 
-       SetBinResult(fTotal2D->GetBin(binEta, binPhi), *fTotal2D);
-    }
-#elif defined (USE_NORM_HIST)
-    fTotal1D->Divide(fNorm);
-    Int_t    nBinEta = fTotal2D->GetXaxis()->GetNbins();
-    Int_t    nBinPhi = fTotal1D->GetXaxis()->GetNbins();
-    for (Int_t binEta = 1; binEta <= nBinEta; binEta++) { 
-      Double_t n = fNorm->GetBinContent(binEta);
-      for (Int_t binPhi = 1; binPhi < nBinPhi; binPhi++) {
-       if (n <= 0) {
-         fTotal2D->SetBinContent(binEta,binPhi,0);
-         continue;
-       }
-       Double_t c = fTotal2D->GetBinContent(binEta,binPhi);
-       fTotal2D->SetBinContent(binEta,binPhi,c/n);
-      }
-    }
-#else 
-#endif
-    // fTotal2D->Scale(1, "width");
-    return kTRUE;
-  }
-
-  //__________________________________________________________________
-  Bool_t SetBinResult(Int_t bin, TH1& in)
-  {
-    Double_t ic = in.GetBinContent(bin);
-    Double_t ie = in.GetBinError(bin);
-    if (ie <= 0.00001) return kTRUE;
-
-    Double_t av = ic / ie;
-    Double_t er = TMath::Sqrt(1/ie);
-
-    // Set bin to be 
-    // @f[ 
-    //    \frac{\sum_i w_i c_i}{\sum_i w_i}
-    // @f]
-    // where @f$ w_i = 1/e_i^2@f$, and set the error to be  
-    // @f[ 
-    //    \sqrt{\frac{1}{\sum_i w_i}}
-    // @f]
-    in.SetBinContent(bin, av);
-    in.SetBinError(bin, er);
-
-    return kTRUE;
-  }    
-  //__________________________________________________________________
-  /** 
-   * Called at the end of the job. 
-   *
-   * It plots the result of the analysis in tree canvases.   
-   * - One shows the per-vertex accumalted histograms and compares them 
-   *   to the per-vertex histograms made in the analysis. 
-   * - Another shows the final @f$ dN_{ch}/d\eta@f$ calculated in 
-   *   different ways and compare those to the  @f$ dN_{ch}/d\eta@f$ made 
-   *   during the analysis. 
-   * - The last canvas shows the @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram. 
-   * 
-   * @return true on succes, false otherwise 
-   */
-  Bool_t Finish() 
-  {
-    TFile* out = TFile::Open("out.root", "RECREATE");
-
-    // Set the style 
-    gStyle->SetOptTitle(0);
-    gStyle->SetPadColor(0);
-    gStyle->SetPadBorderSize(0);
-    gStyle->SetPadBorderMode(0);
-    gStyle->SetPadRightMargin(0.05);
-    gStyle->SetPadTopMargin(0.05);
-    gStyle->SetPalette(1);
-
-    // Get number of bins 
-    Int_t nBin = fBinVzMax-fBinVzMin+1;
-
-    // Make first canvas 
-    TCanvas* cVtx = new TCanvas("cVtx", "By Vertex", 1000, 700);
-    cVtx->SetBorderSize(0);
-    cVtx->SetBorderMode(0);
-    cVtx->Divide((nBin+.5)/2, 2, 0.0005, 0.0005);
-
-    // Loop over vertex histograms 
-    Int_t nHists = 0;
-    for (Int_t i = fBinVzMin; i <= fBinVzMax; i++) { 
-      TDirectory* vtxDir = out->mkdir(Form("vtx%02d", i));
-      vtxDir->cd();
-
-      TH1D* vh1 = static_cast<TH1D*>(fByVtx1D.At(i));
-      if (!vh1) { 
-       Error("Finish", "No histogram at %d", i);
-       continue;
-      }
-      
-      fFromVtx->Add(vh1);
-
-      // Scale and add to output 
-      if (fVtx->GetBinContent(i) > 0)
-       vh1->Scale(1. / fVtx->GetBinContent(i), "width");
-
-      // Write to output file 
-      vh1->Write(); 
-
-      // Divide the pad
-      TVirtualPad* pad = cVtx->cd(i-fBinVzMin+1);
-      pad->Divide(1,2,0.005,0);
-      
-      // Draw the per-vertex histogram 
-      pad->cd(1);
-      vh1->Draw();
-      
-      // Get the same histogram from the analysis and draw it 
-      TProfile* p = 
-       static_cast<TProfile*>(fCollect
-                              ->FindObject(Form("dndeta_vtx%02d",i-1)));
-      p->SetMarkerColor(kBlue+1);
-      p->SetLineColor(kBlue+1);
-      p->SetMarkerSize(0.8);
-      p->SetMarkerStyle(20);
-      p->Draw("same");
-      p->Write();
-
-      // Make the ratio of the two histograms and draw it 
-      pad->cd(2);
-      TH1* ratio = static_cast<TH1*>(vh1->Clone(Form("ratio_vtx%02d", i-1)));
-      // ratio->Scale(1./fEvents->GetBinContent(i));
-      ratio->Divide(p);
-      ratio->SetMarkerSize(.8);
-      ratio->SetLineColor(kGray);
-      ratio->Draw("P");
-    }
-    cVtx->cd();
-    out->cd();
-
-    // Get the number of events selected 
-    // Int_t nEvSelected = fEvents->Integral(fBinVzMin, fBinVzMax);
-    
-    // The second canvas 
-    TCanvas* cTotal1D =  new TCanvas("total", "Result", 800, 800);
-    cTotal1D->SetFillColor(0);
-    cTotal1D->SetBorderMode(0);
-    cTotal1D->SetBorderSize(0);
-    cTotal1D->cd();
-
-    // Make our main pad 
-    TPad* p1 = new TPad("p1", "p1", 0, 0.3, 1.0, 1.0, 0, 0);
-    p1->Draw();
-    p1->cd();
-
-    // Make a stack to 'auto-scale' when plotting more than 1 histogram.
-    THStack* stack = new THStack("results", "Results for #frac{dN_{ch}{d#eta}");
-
-    // Scale the histogram summed over the vertex bins.  This must be 
-    // divided by the number of bins we have summed over.  If we do 
-    // rebinning, we should scale it again. 
-    fFromVtx->Divide(fNorm);
-    // fFromVtx->Scale(1.);
-    fFromVtx->Scale(1, "width"); 
-
-
-    if (fRebin > 1) { fFromVtx->Rebin(fRebin); fFromVtx->Scale(1. / fRebin); }
-    stack->Add(fFromVtx, "");
-
-    // Generate the projection from the direct sum of the input histograms, 
-    // and scale it to the number of vertex bins and the bin width 
-    TH1* proj = fTotal2D->ProjectionX("dndeta_proj", 0, -1, "e");
-    proj->SetLineColor(kGreen+1);
-    proj->SetMarkerColor(kGreen+1);
-    proj->SetMarkerStyle(24);
-    proj->SetMarkerSize(1.5);
-    proj->SetTitle(Form("%s directly", proj->GetTitle()));
-    proj->Divide(fNorm);
-    proj->Scale(1., "width");
-    stack->Add(proj, "");
-    
-    // Scale our direct sum of the projects of the input histograms to 
-    // the number of vertex bins and the bin width. If we do rebinning, 
-    // we must scale it one more time.
-    // fTotal1D->Scale(1. / fNAccepted, "width");
-    fTotal1D->Divide(fNorm);
-    fTotal1D->Scale(1., "width");
-    if (fRebin > 1) { fTotal1D->Rebin(fRebin); fTotal1D->Scale(1. / fRebin); }
-    stack->Add(fTotal1D);
-
-    // Get the result from the analysis and plit that too (after modifying 
-    // the style and possible rebinning)
-    TProfile* dtotal = static_cast<TProfile*>(fCollect->FindObject("dndeta"));
-    if (!dtotal) {
-      Error("Finish", "Couldn't get the event histogram");
-      return kFALSE;
-    }
-    dtotal->SetTitle(Form("%s directly", dtotal->GetTitle()));
-    dtotal->SetLineColor(kBlue+1);
-    dtotal->SetMarkerColor(kBlue+1);
-    dtotal->SetMarkerStyle(20);
-    dtotal->SetMarkerSize(0.8);
-    if (fRebin > 1) { dtotal->Rebin(fRebin); }
-    stack->Add(dtotal, "");
-
-    // Draw stack 
-    stack->Draw("nostack e1");
-    stack->Write();
-
-    // Make a legend 
-    TLegend* l = p1->BuildLegend(0.31, 0.15, 0.5, 0.6);
-    l->SetFillColor(0);
-    l->SetBorderSize(0);
-    l->SetTextSize(0.04); // l->GetTextSize()/3);
-    cTotal1D->cd();
-
-    // Generate our second pad 
-    TPad* p2 = new TPad("p2", "p2", 0, 0.0, 1.0, 0.3, 0, 0);
-    p2->Draw();
-    p2->cd();
-
-    // Create a new stack 
-    stack = new THStack("ratios", "Ratios to old method");
-    // Calculate the ratio of our summed over vertex bins to the 
-    // result from the analysis and draw it 
-    TH1* ratioVtx = static_cast<TH1*>(fFromVtx->Clone("ratioVtx"));
-    ratioVtx->SetDirectory(0);
-    ratioVtx->Divide(dtotal);
-    stack->Add(ratioVtx, "");
-
-    // Calculate the ratio of our direct sum of input histograms 
-    // result from the analysis  and draw it 
-    TH1* ratioSum = static_cast<TH1*>(fTotal1D->Clone("ratioSum"));
-    ratioSum->SetDirectory(0);
-    ratioSum->Divide(dtotal);
-    stack->Add(ratioSum, "");
-
-    // Calculate the ratio of our direct sum of input histograms 
-    // result from the analysis  and draw it 
-    TH1* ratioProj = static_cast<TH1*>(proj->Clone("ratioProj"));
-    ratioProj->SetDirectory(0);
-    ratioProj->Divide(dtotal);
-    stack->Add(ratioProj, "");
-    
-    stack->Draw("nostack e1");
-    stack->Write();
-
-    // update 
-    cTotal1D->cd();
-
-    // Generate the last canvas and show the summed input histogram 
-    TCanvas* other = new TCanvas("other", "Other", 800, 600);
-    other->SetFillColor(0);
-    other->SetBorderMode(0);
-    other->SetBorderSize(0);
-    other->Divide(2,1);
-
-    other->cd(1);
-    fNorm->Draw("HIST");
-    fNorm->Write();
-    
-    other->cd(2);
-    fEvents->Draw();
-    fVtx->Draw("same");
-    fEvents->Write();
-    // fTotal2D->Draw("lego2 e");
-
-    return kTRUE;
-  }
-  //__________________________________________________________________
-  /** 
-   * Run the post-processing.  
-   * 
-   * This will open the files &lt;<i>base</i>&gt;<tt>_hists.root</tt>
-   * containing the histograms generated by AliForwardMultiplicity and
-   * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the
-   * tree with AliAODEvent objects. 
-   *
-   * Then it will loop over the events, accepting only INEL events
-   * that have a primary collision point along z within @a vzMin and
-   * @a vzMax.
-   *
-   * After the processing, the result will be shown in 3 canvases, 
-   * possibly  rebinning the result by the factor @a rebin. 
-   * 
-   * @param base  Base name of files 
-   * @param vzMin Minimum collision vertex z position to use
-   * @param vzMax Maximum collision vertex z position to use
-   * @param rebin Rebinning factor 
-   * 
-   * @return true on success, false otherwise 
-   */
-  Bool_t Run(const char* base,
-            Double_t    vzMin=-10, 
-            Double_t    vzMax=10, 
-            Int_t       rebin=1) 
-  {
-    if (!Open(base,vzMin,vzMax,rebin)) return kFALSE;
-    if (!Process()) return kFALSE;
-    if (!Finish()) return kFALSE;
-
-    return kTRUE;
-  }
-protected:
-  Double_t           fVzMin;     // Minimum vertex 
-  Double_t           fVzMax;     // Maximum vertex
-  Int_t              fBinVzMin;  // Corresponding bin to min vertex
-  Int_t              fBinVzMax;  // Corresponding bin to max vertex
-  Int_t              fRebin;     // Rebin factor 
-  TTree*             fTree;      // Event tree 
-  AliAODForwardMult* fAOD;       // Our event-by-event data
-  TH1I*              fEvents;    // histogram of event counts per vertex 
-  TList*             fCollect;   // List of analysis histograms
-  TObjArray          fByVtx1D;   // List of per-vertex 1D histograms
-  TH1D*              fTotal1D;   // Direct sum of input histograms
-  TH2D*              fTotal2D;   // Direct sum of input histograms
-  TH1D*              fFromVtx;   // Sum of per-vertex histograms 
-  TH1D*              fNorm;      // Histogram of # events with data per bin 
-  TH1D*              fVtx;
-  Int_t              fNAccepted; // # of accepted events 
-};
-
-//
-// EOF
-//
diff --git a/PWG2/FORWARD/analysis2/older/DrawResVtx.C b/PWG2/FORWARD/analysis2/older/DrawResVtx.C
deleted file mode 100644 (file)
index 3a0bc07..0000000
+++ /dev/null
@@ -1,252 +0,0 @@
-#include "DrawRes1D.C"
-
-/** 
- * @defgroup pwg2_forward_analysis_scripts PWG2 Forward analysis - scripts
- *
- * @ingroup pwg2_forward_analysis
- */
-/** 
- * Example macro to loop over the event-by-event 2D histogram of 
- * @f[
- *   \frac{d^{2}N_{ch}}{d\eta\,d\phi}
- * @f]
- * stored in an AOD.  
- * 
- * The class needs the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
- * containing the histograms generated by AliForwardMultiplicity and 
- * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
- * with AliAODEvent objects where AliAODForwardMult objects have been 
- * added to in the branch <tt>Forward</tt>
- * 
- * @ingroup pwg2_forward_analysis_scripts
- */
-class DrawResVtx : public DrawRes1D
-{
-public:
-  /** 
-   * Constructor 
-   * 
-   * @param special If true, add to the list of 'specials'
-   */
-  DrawResVtx()
-    : fByVtx1D(0)
-  {}
-  //__________________________________________________________________
-  /** 
-   * Open the files &lt;<i>base</i>&gt;<tt>_hists.root</tt> 
-   * containing the histograms generated by AliForwardMultiplicity and 
-   * the file &lt;<i>base</i>&gt;<tt>_aods.root</tt> containing the tree 
-   * with AliAODEvent objects.
-   * 
-   * @param base  Base name of files 
-   * @param vzMin Minimum collision vertex z position to use
-   * @param vzMax Maximum collision vertex z position to use
-   * @param rebin Rebinning factor 
-   * 
-   * @return true on success, false otherwise 
-   */
-  Bool_t Open(const char* base, 
-             Double_t    vzMin=-10, 
-             Double_t    vzMax=10)
-  {
-    // Clear previously created data objects 
-    fByVtx1D.Delete();
-    return DrawRes1D::Open(base, vzMin, vzMax);
-  }
-
-  //__________________________________________________________________
-  /** 
-   * Make a 1D histogram of @f$ dN_{ch}/d\eta@f$ with the given name and 
-   * title 
-   * 
-   * @param name   Name of histogram 
-   * @param title  Title of histogram 
-   * @param a1     Eta axis 
-   * 
-   * @return Newly allocated 1D histogram object 
-   */
-  TH1D* Make1D(const char* name, const char* title, const TAxis* a1)
-  {
-    TH1D* ret = new TH1D(name, title,
-                        a1->GetNbins(), a1->GetXmin(), a1->GetXmax());
-    ret->SetXTitle("#eta");
-    ret->SetYTitle("#frac{1}{N}#frac{dN_{ch}}{d#eta}");
-    ret->Sumw2();
-    ret->SetMarkerColor(kRed+1);
-    ret->SetLineColor(kRed+1);
-    ret->SetMarkerStyle(20);
-    ret->SetMarkerSize(1);
-    ret->SetStats(0);
-    ret->SetDirectory(0);
-
-    return ret;
-  }
-  //__________________________________________________________________
-  /** 
-   * Utility function to set-up histograms based on the input 
-   * @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram.   This member function 
-   * is called on the first event so that we have the proper binning 
-   * 
-   * @param templ Input histogram
-   * 
-   * @return true on succcess
-   */
-  Bool_t FirstEvent(const TH2D& templ) 
-  { 
-    if (!DrawRes1D::FirstEvent(templ)) return kFALSE;
-
-    const TAxis* etaAxis = templ.GetXaxis();
-    
-    // Generate the per-vertex bin histograms.  These will be the sum 
-    // of each of the per-event input histograms for a given vertex range. 
-    for (Int_t i = fBinVzMin; i <= fBinVzMax; i++) { 
-      TH1* h1 = Make1D(Form("dndeta_vz%02d", i), 
-                      Form("#frac{1}{N}#frac{dN_{ch}}{d#eta}, vtxbin=%d", i),
-                      etaAxis);
-      fByVtx1D.AddAtAndExpand(h1, i);
-    }
-    return kTRUE;
-  }
-
-
-  //__________________________________________________________________
-  /** 
-   * Process the events 
-   * 
-   * 
-   * @return true on success, false otherwise 
-   */
-  void AddContrib(const TH2D& hist, Int_t vtxBin)
-  {
-    // Get 'by-vertex' histograms 
-    TH1* tmp1 = static_cast<TH1D*>(fByVtx1D.At(vtxBin));
-    if (!tmp1) { 
-      Warning("Process", "No histogram for vertex bin %d)",vtxBin);
-      return;
-    }
-    // Make a projection on the X axis of the input histogram 
-    TH1D*    proj  = hist.ProjectionX("_px", 0, -1, "e");
-    
-    // Add to per-vertex histogram 
-    tmp1->Add(proj); 
-    
-    delete proj;
-  } 
-  //__________________________________________________________________
-  /** 
-   * Called at the end of the job. 
-   *
-   * It plots the result of the analysis in tree canvases.   
-   * - One shows the per-vertex accumalted histograms and compares them 
-   *   to the per-vertex histograms made in the analysis. 
-   * - Another shows the final @f$ dN_{ch}/d\eta@f$ calculated in 
-   *   different ways and compare those to the  @f$ dN_{ch}/d\eta@f$ made 
-   *   during the analysis. 
-   * - The last canvas shows the @f$ dd^{2}N_{ch}/d\eta\,d\phi@f$ histogram. 
-   * 
-   * @return true on succes, false otherwise 
-   */
-  TH1D* GetResult() 
-  {
-    // Get number of bins 
-    Int_t nBin = fBinVzMax-fBinVzMin+1;
-
-    // Make first canvas 
-    TCanvas* cVtx = new TCanvas("cVtx", "By Vertex", 1000, 700);
-    cVtx->SetBorderSize(0);
-    cVtx->SetBorderMode(0);
-    cVtx->Divide((nBin+.5)/2, 2, 0.0005, 0.0005);
-
-    // Loop over vertex histograms 
-    TDirectory* savdir = gDirectory;
-    for (Int_t i = fBinVzMin; i <= fBinVzMax; i++) { 
-      TDirectory* vtxDir = savdir->mkdir(Form("vtx%02d", i));
-      vtxDir->cd();
-
-      TH1D* vh1 = static_cast<TH1D*>(fByVtx1D.At(i));
-      if (!vh1) { 
-       Error("Finish", "No histogram at %d", i);
-       continue;
-      }
-      
-      fTotal1D->Add(vh1);
-
-      // Scale and add to output 
-      if (fVtx->GetBinContent(i) > 0)
-       vh1->Scale(1. / fVtx->GetBinContent(i), "width");
-
-      // Write to output file 
-      vh1->Write(); 
-
-      // Divide the pad
-      TVirtualPad* pad = cVtx->cd(i-fBinVzMin+1);
-      pad->Divide(1,2,0.005,0);
-      
-      // Draw the per-vertex histogram 
-      pad->cd(1);
-      vh1->DrawClone();
-      
-      // Get the same histogram from the analysis and draw it 
-      TProfile* p = 
-       static_cast<TProfile*>(fCollect
-                              ->FindObject(Form("dndeta_vtx%02d",i-1)));
-      p->SetMarkerColor(kBlue+1);
-      p->SetLineColor(kBlue+1);
-      p->SetMarkerSize(0.8);
-      p->SetMarkerStyle(20);
-      p->DrawClone("same");
-      p->Write();
-
-      // Make the ratio of the two histograms and draw it 
-      pad->cd(2);
-      TH1* ratio = static_cast<TH1*>(vh1->Clone(Form("ratio_vtx%02d", i-1)));
-      // ratio->Scale(1./fEvents->GetBinContent(i));
-      ratio->Divide(p);
-      ratio->SetMarkerSize(.8);
-      ratio->SetLineColor(kGray);
-      ratio->DrawClone("P");
-    }
-    cVtx->cd();
-    savdir->cd();
-
-    // Scale the histogram summed over the vertex bins.  This must be 
-    // divided by the number of bins we have summed over.  If we do 
-    // rebinning, we should scale it again. 
-    fTotal1D->Divide(fNorm);
-    fTotal1D->Scale(1, "width"); 
-    return fTotal1D;
-  }
-  /** 
-   * Browse this object 
-   * 
-   * @param b Browser to use 
-   */
-  void Browse(TBrowser* b) 
-  {
-    b->Add(&fByVtx1D);
-    DrawRes1D::Browse(b);
-  }
-  /** 
-   * Create a new object of this class, and add it to the list of 
-   * specials, and create a browse and browse to this object 
-   * 
-   * @return Newly created object
-   */
-  static DrawResVtx* Create() 
-  {
-    DrawResVtx* dr = new DrawResVtx;
-    gROOT->GetListOfSpecials()->Add(dr);
-    TBrowser* b = new TBrowser("b");
-    b->BrowseObject(gROOT->GetListOfSpecials());
-    return dr;
-  }
-
-protected:
-  TObjArray          fByVtx1D;   // List of per-vertex 1D histograms
-
-  ClassDef(DrawResVtx,0)
-};
-
-//
-// EOF
-//