Fixes
authorcholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Mar 2011 14:45:21 +0000 (14:45 +0000)
committercholm <cholm@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 28 Mar 2011 14:45:21 +0000 (14:45 +0000)
PWG2/FORWARD/analysis2/AliAODForwardMult.cxx
PWG2/FORWARD/analysis2/AliBasedNdetaTask.cxx
PWG2/FORWARD/analysis2/AliFMDDensityCalculator.cxx
PWG2/FORWARD/analysis2/AliFMDDensityCalculator.h
PWG2/FORWARD/analysis2/AliFMDMCDensityCalculator.cxx
PWG2/FORWARD/analysis2/AliForwarddNdetaTask.cxx
PWG2/FORWARD/analysis2/MakeAOD.C
PWG2/FORWARD/analysis2/OtherData.C
PWG2/FORWARD/analysis2/TrainSetup.C

index 1a7d629..acb8908 100644 (file)
@@ -247,6 +247,10 @@ AliAODForwardMult::MakeTriggerMask(const char* what)
     if      (s.CompareTo("INEL")  == 0) trgMask |= AliAODForwardMult::kInel;
     else if (s.CompareTo("INEL>0")== 0) trgMask |= AliAODForwardMult::kInelGt0;
     else if (s.CompareTo("NSD")   == 0) trgMask |= AliAODForwardMult::kNSD;
+    else if (s.CompareTo("B")     == 0) trgMask |= AliAODForwardMult::kB;
+    else if (s.CompareTo("A")     == 0) trgMask |= AliAODForwardMult::kA;
+    else if (s.CompareTo("C")     == 0) trgMask |= AliAODForwardMult::kC;
+    else if (s.CompareTo("E")     == 0) trgMask |= AliAODForwardMult::kE;
     else 
       AliWarningGeneral("MakeTriggerMask", 
                        Form("Unknown trigger %s", s.Data()));
@@ -308,11 +312,11 @@ AliAODForwardMult::CheckEvent(Int_t    triggerMask,
   if (hist) hist->AddBinContent(kWithTrigger);
   
   // Check that we have a valid vertex
-  if (!HasIpZ()) return false;
+  if (vzMin < vzMax && !HasIpZ()) return false;
   if (hist) hist->AddBinContent(kWithVertex);
 
   // Check that vertex is within cuts 
-  if (!InRange(vzMin, vzMax)) return false;
+  if (vzMin < vzMax && !InRange(vzMin, vzMax)) return false;
   if (hist) hist->AddBinContent(kAccepted);
   
   return true;
index a100dbe..bb7cab4 100644 (file)
@@ -952,6 +952,7 @@ AliBasedNdetaTask::CentralityBin::CreateSums(const TH2D* data, const TH2D* mc)
   if (!mc) return;
 
   fSumMC = static_cast<TH2D*>(mc->Clone(Form("%sMC", GetName())));
+  fSumMC->SetTitle(Form("%s (MC)", fSumMC->GetTitle()));
   fSumMC->SetDirectory(0);
   fSumMC->Reset();
   fSums->Add(fSumMC);
index ae79799..99df429 100644 (file)
@@ -38,6 +38,8 @@ AliFMDDensityCalculator::AliFMDDensityCalculator()
     fFMD2oMax(0),
     fFMD3iMax(0),
     fFMD3oMax(0),
+    fEtaLumping(1), 
+    fPhiLumping(1),    
     fDebug(0)
 {
   // 
@@ -63,6 +65,8 @@ AliFMDDensityCalculator::AliFMDDensityCalculator(const char* title)
     fFMD2oMax(0),
     fFMD3iMax(0),
     fFMD3oMax(0),
+    fEtaLumping(5), 
+    fPhiLumping(1),
     fDebug(0)
 {
   // 
@@ -113,6 +117,8 @@ AliFMDDensityCalculator::AliFMDDensityCalculator(const
     fFMD2oMax(o.fFMD2oMax),
     fFMD3iMax(o.fFMD3iMax),
     fFMD3oMax(o.fFMD3oMax),
+    fEtaLumping(o.fEtaLumping), 
+    fPhiLumping(o.fPhiLumping),
     fDebug(o.fDebug)
 {
   // 
@@ -161,7 +167,8 @@ AliFMDDensityCalculator::operator=(const AliFMDDensityCalculator& o)
   fFMD2oMax     = o.fFMD2oMax;
   fFMD3iMax     = o.fFMD3iMax;
   fFMD3oMax     = o.fFMD3oMax;
-
+  fEtaLumping   = o.fEtaLumping;
+  fPhiLumping   = o.fPhiLumping;
   fRingHistos.Delete();
   TIter    next(&o.fRingHistos);
   TObject* obj = 0;
@@ -265,7 +272,7 @@ AliFMDDensityCalculator::Calculate(const AliESDFMD&        fmd,
        fRingHistos.ls();
        return false;
       }
-      rh->ResetPoissonHistos();
+      rh->ResetPoissonHistos(h, fEtaLumping, fPhiLumping);
       
       for (UShort_t s=0; s<ns; s++) { 
        for (UShort_t t=0; t<nt; t++) {
@@ -293,46 +300,36 @@ AliFMDDensityCalculator::Calculate(const AliESDFMD&        fmd,
          rh->fEtaVsM->Fill(eta, n);
          rh->fCorr->Fill(eta, c);
          
-         //if (n < .9) rh->fEmptyStrips->Fill(eta,phi);
-         if (n > 0.9) rh->fBasicHits->Fill(eta,phi);
+         if (n > 0.9 && c > 0) rh->fBasicHits->Fill(eta,phi, 1./c);
+         else                  rh->fEmptyStrips->Fill(eta,phi);
            
          h->Fill(eta,phi,n);
          rh->fDensity->Fill(eta,phi,n);
        } // for t
       } // for s 
-      //std::cout<<rh->fTotalStrips->GetEntries()<<"  "<<rh->fEmptyStrips->GetEntries()<<std::endl;
-      // Loop over poisson histograms 
+
+
+      // --- Loop over poisson histograms ----------------------------
       for (Int_t ieta = 1; ieta <= h->GetNbinsX(); ieta++) { 
        for (Int_t iphi = 1; iphi <= h->GetNbinsY(); iphi++) { 
          Double_t eLossV   = h->GetBinContent(ieta, iphi);
-         // Double_t eLossE   = h->GetBinError(ieta, iphi);
-         Float_t eta       = h->GetXaxis()->GetBinCenter(ieta);
-         Float_t phi       = h->GetYaxis()->GetBinCenter(iphi);
-         Double_t empty    = rh->fEmptyStrips->GetBinContent(rh->fEmptyStrips->GetXaxis()->FindBin(eta),
-                                                             rh->fEmptyStrips->GetYaxis()->FindBin(phi)) ;
-         Double_t total    = rh->fTotalStrips->GetBinContent(rh->fTotalStrips->GetXaxis()->FindBin(eta),
-                                                             rh->fTotalStrips->GetYaxis()->FindBin(phi));
-         
-         Double_t corr     = rh->fCorr->GetBinContent(rh->fCorr->GetXaxis()->FindBin(eta));
-         
-         
+         Float_t  eta      = h->GetXaxis()->GetBinCenter(ieta);
+         Float_t  phi      = h->GetYaxis()->GetBinCenter(iphi);
+         Int_t    jeta     = rh->fEmptyStrips->GetXaxis()->FindBin(eta);
+         Int_t    jphi     = rh->fEmptyStrips->GetYaxis()->FindBin(phi);
+         Double_t empty    = rh->fEmptyStrips->GetBinContent(jeta, jphi);
+         Double_t total    = rh->fTotalStrips->GetBinContent(jeta, jphi);
          Double_t hits     = rh->fBasicHits->GetBinContent(ieta,iphi);
-         
-         Double_t poissonV =  (total <= 0 || empty <= 0 ? 0 : 
-                               -TMath::Log(empty / total));
-         if(poissonV > 0)
-           poissonV = (hits * poissonV) / (1 - TMath::Exp(-1*poissonV));
-         if(corr > 0) {
-           poissonV = poissonV / corr;
-         }
-         //else poissonV = 0;
-         // if ( eLossV > 0)
-         //  std::cout<<"event : "<<total<<"  "<<empty<<"  "<<hits<<"  "<<poissonV<<"  "<<eLossV<<std::endl;
+         // Mean in region of interest 
+         Double_t poissonM = (total <= 0 || empty <= 0 ? 0 : 
+                              -TMath::Log(empty / total));
+         Double_t poissonV = 0;
+         if(poissonM > 0)
+           // Correct for counting statistics and weight by counts 
+           poissonV = (hits * poissonM) / (1 - TMath::Exp(-1*poissonM));
          Double_t poissonE = 0 ;
          if(poissonV > 0) poissonE = TMath::Sqrt(poissonV);
          
-
-         
          rh->fELossVsPoisson->Fill(eLossV, poissonV);
          rh->fEmptyVsTotal->Fill(total, empty);
          if (fUsePoisson) {
@@ -942,7 +939,9 @@ AliFMDDensityCalculator::RingHistos::~RingHistos()
 
 //____________________________________________________________________
 void
-AliFMDDensityCalculator::RingHistos::ResetPoissonHistos()
+AliFMDDensityCalculator::RingHistos::ResetPoissonHistos(const TH2D* h,
+                                                       Int_t etaLumping,
+                                                       Int_t phiLumping)
 {
   if (fTotalStrips) { 
     fTotalStrips->Reset();
@@ -952,43 +951,24 @@ AliFMDDensityCalculator::RingHistos::ResetPoissonHistos()
   }
   //Inserted by HHD
   
-  //Float_t nbinlimitsFMD3I[8] =  {-3.4,-3.2,-3,-2.8,-2.6,-2.4,-2.2,-2};
-  Int_t nbins = 40;
-  /*if(fName.Contains("FMD1I")) nbins = 7;
-  if(fName.Contains("FMD2I")) nbins = 8;
-  if(fName.Contains("FMD2O")) nbins = 4;
-  if(fName.Contains("FMD3I")) nbins = 8;
-  if(fName.Contains("FMD3O")) nbins = 4;*/
-  Float_t lowlimit = -4, highlimit = 6;
-  /*if(fName.Contains("FMD1I")) {lowlimit = 3.6; highlimit = 5;}
-  if(fName.Contains("FMD2I")) {lowlimit = 2.2; highlimit = 3.8;}
-  if(fName.Contains("FMD2O")) {lowlimit = 1.6; highlimit = 2.4;} 
-  if(fName.Contains("FMD3I")) {lowlimit = -2.4; highlimit = -1.6;}
-  if(fName.Contains("FMD3O")) {lowlimit = -3.5; highlimit = -2.1;} 
-  
-  std::cout<<nbins<<"   "<<lowlimit<<"    "<<highlimit<<std::endl;
-  */
+  Int_t    nEta    = h->GetNbinsX() / etaLumping;
+  Int_t    nEtaF   = h->GetNbinsX();
+  Double_t etaMin  = h->GetXaxis()->GetXmin();
+  Double_t etaMax  = h->GetXaxis()->GetXmax();
+  Int_t    nPhi    = h->GetNbinsY() / phiLumping;
+  Int_t    nPhiF   = h->GetNbinsY();
+  Double_t phiMin  = h->GetYaxis()->GetXmin();
+  Double_t phiMax  = h->GetYaxis()->GetXmax();
+
   fTotalStrips = new TH2D(Form("total%s", fName.Data()), 
                          Form("Total number of strips in %s", fName.Data()), 
-                         nbins, 
-                         lowlimit,
-                         highlimit, 
-                         (fRing == 'I' || fRing == 'i' ? 5 : 10), 
-                         0, 2*TMath::Pi());
+                         nEta, etaMin, etaMax, nPhi, phiMin, phiMax);
   fEmptyStrips = new TH2D(Form("empty%s", fName.Data()), 
                          Form("Empty number of strips in %s", fName.Data()), 
-                         nbins, 
-                         lowlimit,
-                         highlimit, 
-                         (fRing == 'I' || fRing == 'i' ? 5 : 10), 
-                         0, 2*TMath::Pi());
+                         nEta, etaMin, etaMax, nPhi, phiMin, phiMax);
   fBasicHits   = new TH2D(Form("basichits%s", fName.Data()), 
                          Form("Basic number of hits in %s", fName.Data()), 
-                         200, 
-                         -4, 
-                         6, 
-                         (fRing == 'I' || fRing == 'i' ? 20 : 40), 
-                         0, 2*TMath::Pi());
+                         nEtaF, etaMin, etaMax, nPhiF, phiMin, phiMax);
   
   fTotalStrips->SetDirectory(0);
   fEmptyStrips->SetDirectory(0);
@@ -1008,44 +988,6 @@ AliFMDDensityCalculator::RingHistos::ResetPoissonHistos()
 void
 AliFMDDensityCalculator::RingHistos::Init(const TAxis& /*eAxis*/)
 {
-  /*if (fTotalStrips) delete fTotalStrips;
-  if (fEmptyStrips) delete fEmptyStrips;
-  if (fBasicHits) delete fBasicHits;
-  
-  fTotalStrips = new TH2D(Form("total%s", fName.Data()), 
-                         Form("Total number of strips in %s", fName.Data()), 
-                         eAxis.GetNbins()/5., 
-                         eAxis.GetXmin(),
-                         eAxis.GetXmax(), 
-                         (fRing == 'I' || fRing == 'i' ? 5 : 5), 
-                         0, 2*TMath::Pi());
-  fEmptyStrips = new TH2D(Form("empty%s", fName.Data()), 
-                         Form("Empty number of strips in %s", fName.Data()), 
-                         eAxis.GetNbins()/5., 
-                         eAxis.GetXmin(), 
-                         eAxis.GetXmax(), 
-                         (fRing == 'I' || fRing == 'i' ? 5 : 10), 
-                         0, 2*TMath::Pi());
-  fBasicHits   = new TH2D(Form("basichits%s", fName.Data()), 
-                         Form("Basic number of hits in %s", fName.Data()), 
-                         eAxis.GetNbins(), 
-                         eAxis.GetXmin(), 
-                         eAxis.GetXmax(), 
-                         (fRing == 'I' || fRing == 'i' ? 20 : 40), 
-                         0, 2*TMath::Pi());
-  
-  fTotalStrips->SetDirectory(0);
-  fEmptyStrips->SetDirectory(0);
-  fBasicHits->SetDirectory(0);
-  fTotalStrips->SetXTitle("#eta");
-  fEmptyStrips->SetXTitle("#eta");
-  fBasicHits->SetXTitle("#eta");
-  fTotalStrips->SetYTitle("#varphi [radians]");
-  fEmptyStrips->SetYTitle("#varphi [radians]");
-  fBasicHits->SetYTitle("#varphi [radians]");
-  fTotalStrips->Sumw2();
-  fEmptyStrips->Sumw2();
-  fBasicHits->Sumw2();*/
 }
 
 //____________________________________________________________________
index 02ea264..af0f07a 100644 (file)
@@ -139,6 +139,16 @@ public:
    * @param cut Cut to use 
    */
   void SetMultCut(Double_t cut) { fMultCut = cut; }
+  /** 
+   * Set the luming factors used in the Poisson method
+   * 
+   * @param eta Must be 1 or larger 
+   * @param phi Must be 1 or larger 
+   */
+  void SetLumping(Int_t eta, Int_t phi) { 
+    fEtaLumping = (eta < 1 ? 1 : eta); 
+    fPhiLumping = (phi < 1 ? 1 : phi); 
+  }
   /** 
    * Get the multiplicity cut.  If the user has set fMultCut (via
    * SetMultCut) then that value is used.  If not, then the lower
@@ -303,18 +313,18 @@ protected:
     /** 
      * Create Poisson histograms 
      */
-    void ResetPoissonHistos();
-    TH2D*     fEvsN;         // Correlation of Eloss vs uncorrected Nch
-    TH2D*     fEvsM;         // Correlation of Eloss vs corrected Nch
-    TProfile* fEtaVsN;       // Average uncorrected Nch vs eta
-    TProfile* fEtaVsM;       // Average corrected Nch vs eta
-    TProfile* fCorr;         // Average correction vs eta
-    TH2D*     fDensity;      // Distribution inclusive Nch
+    void ResetPoissonHistos(const TH2D* h, Int_t etaLumping, Int_t phiLumping);
+    TH2D*     fEvsN;           // Correlation of Eloss vs uncorrected Nch
+    TH2D*     fEvsM;           // Correlation of Eloss vs corrected Nch
+    TProfile* fEtaVsN;         // Average uncorrected Nch vs eta
+    TProfile* fEtaVsM;         // Average corrected Nch vs eta
+    TProfile* fCorr;           // Average correction vs eta
+    TH2D*     fDensity;        // Distribution inclusive Nch
     TH2D*     fELossVsPoisson; // Correlation of energy loss vs Poisson N_ch
-    TH2D*     fTotalStrips;  // Total number of strips in a region
-    TH2D*     fEmptyStrips;  // Total number of strips in a region
-    TH2D*     fBasicHits  ;  // Total number basic hits in a region
-    TH2D*     fEmptyVsTotal; // # of empty strips vs total number of strips 
+    TH2D*     fTotalStrips;    // Total number of strips in a region
+    TH2D*     fEmptyStrips;    // Total number of strips in a region
+    TH2D*     fBasicHits  ;    // Total number basic hits in a region
+    TH2D*     fEmptyVsTotal;   // # of empty strips vs total number of strips 
     
     
     ClassDef(RingHistos,3);
@@ -343,8 +353,11 @@ protected:
   TArrayI  fFMD2oMax;      //  Array of max weights 
   TArrayI  fFMD3iMax;      //  Array of max weights 
   TArrayI  fFMD3oMax;      //  Array of max weights 
+  Int_t    fEtaLumping;    //  How to lump eta bins for Poisson 
+  Int_t    fPhiLumping;    //  How to lump phi bins for Poisson 
   Int_t    fDebug;         //  Debug level 
 
+
   ClassDef(AliFMDDensityCalculator,2); // Calculate Nch density 
 };
 
index 76cb4e8..63d1bd7 100644 (file)
@@ -108,7 +108,7 @@ AliFMDMCDensityCalculator::CalculateMC(const AliESDFMD&        fmd,
   // Calculate the charged particle density from the MC track references. 
   // 
   // Parameters:
-  //    event  MC event
+  //    fmd    Forward MC event
   //    hists  Histograms to fill
   //    vz     Interaction z coordinate @f$ v_z@f$
   //    vtxBin bin corresponding to @f$ v_z@f$
index 0e0b06b..0b9484d 100644 (file)
@@ -132,8 +132,8 @@ void
 AliForwarddNdetaTask::CentralityBin::ProcessPrimary(const AliAODForwardMult* 
                                                    forward, 
                                                    Int_t triggerMask,
-                                                   Double_t vzMin
-                                                   Double_t vzMax
+                                                   Double_t /*vzMin*/
+                                                   Double_t /*vzMax*/
                                                    const TH2D* primary)
 { 
   // Check the centrality class unless this is the 'all' bin 
@@ -149,18 +149,16 @@ AliForwarddNdetaTask::CentralityBin::ProcessPrimary(const AliAODForwardMult*
     fSumPrimary->Reset();
     fSums->Add(fSumPrimary);
   }
-  if (triggerMask == AliAODForwardMult::kNSD && forward->IsTriggerBits(triggerMask|AliAODForwardMult::kB)) 
-    fSumPrimary->Add(primary);
   
-  // translate rea trigger mask to MC trigger mask
+  // translate real trigger mask to MC trigger mask
   Int_t mask = AliAODForwardMult::kB;
   if (triggerMask == AliAODForwardMult::kNSD)
     mask = AliAODForwardMult::kMCNSD;
 
-  // Now use our normal check, but with the new mask 
-  if (!forward->CheckEvent(mask, vzMin, vzMax, 0, 0, 0)) return;
+  // Now use our normal check, but with the new mask, except 
+  if (!forward->CheckEvent(mask, -1000, -1000, 0, 0, 0)) return;
 
-  
+  fSumPrimary->Add(primary);
 }
 
 //________________________________________________________________________
@@ -189,7 +187,11 @@ AliForwarddNdetaTask::CentralityBin::End(TList*      sums,
 
   fSumPrimary     = static_cast<TH2D*>(fSums->FindObject("truth"));
 
-  if (!fSumPrimary) return;
+  if (!fSumPrimary) { 
+    AliWarning("No MC truth histogram found");
+    fSums->ls();
+    return;
+  }
   Int_t n = (triggerMask == AliAODForwardMult::kNSD ? 
             Int_t(fTriggers->GetBinContent(AliAODForwardMult::kBinMCNSD)) : 
             Int_t(fTriggers->GetBinContent(AliAODForwardMult::kBinAll)));
index 4d8aea2..333ae06 100644 (file)
@@ -51,7 +51,7 @@ void MakeAOD(const char* esddir,
     gSystem->AddIncludePath("-I${ALICE_ROOT}/include");
     gSystem->Load("libANALYSIS");
     gSystem->Load("libANALYSISalice");
-    gROOT->LoadMacro("TrainSetup.C+");
+    gROOT->LoadMacro("TrainSetup.C+g");
     MakeAODTrain t(name, 0, 0, 0, centrality, false);
     t.SetDataDir(esddir);
     t.SetDataSet("");
index 915c3c0..6bffe59 100644 (file)
@@ -26,6 +26,7 @@ enum {
   UA5, 
   CMS, 
   ALICE, 
+  PYTHIA,
   INEL, 
   INELGt0, 
   NSD
@@ -37,12 +38,16 @@ enum {
   CMSStyle   = 29, 
   /** Style used for ALICE published data */
   ALICEStyle = 27,
+  /** Style used for Pythia data */
+  PYTHIAStyle = 28,
   /** Color used for UA5 data */
   UA5Color   = kBlue+1,
+  /** Color used for Pytia data */
+  PYTHIAColor = kGray+2,
   /** Color used for CMS data */
   CMSColor   = kGreen+1,
   /** Color used for ALICE data */
-  ALICEColor = kMagenta+1,
+  ALICEColor = kMagenta+1
 }; 
 enum { 
   /** Marker style INEL data */
@@ -82,15 +87,17 @@ SetGraphAttributes(TGraph* g, Int_t trig, Int_t exp, bool mirror,
 {
   Int_t color = 0;
   switch (exp) { 
-  case UA5:   color = UA5Color;   break;
-  case CMS:   color = CMSColor;   break;
-  case ALICE: color = ALICEColor; break;
+  case UA5:    color = UA5Color;    break;
+  case CMS:    color = CMSColor;    break;
+  case ALICE:  color = ALICEColor;  break;
+  case PYTHIA: color = PYTHIAColor; break;
   }
   Int_t style = 0;
   switch (exp) { 
-  case UA5:   style = UA5Style;   break;
-  case CMS:   style = CMSStyle;   break;
-  case ALICE: style = ALICEStyle; break;
+  case UA5:    style = UA5Style;    break;
+  case CMS:    style = CMSStyle;    break;
+  case ALICE:  style = ALICEStyle;  break;
+  case PYTHIA: style = PYTHIAStyle; break;
   }
   Float_t size = g->GetMarkerSize();
   switch (style) {
@@ -114,6 +121,431 @@ SetGraphAttributes(TGraph* g, Int_t trig, Int_t exp, bool mirror,
   g->GetHistogram()->SetYTitle("#frac{1}{N} #frac{dN_{ch}}{#eta}");
 }
 
+//____________________________________________________________________
+TGraphAsymmErrors*
+Pythia900INEL()
+{
+   
+  TGraphAsymmErrors *gre = new TGraphAsymmErrors(100);
+  SetGraphAttributes(gre, INEL, PYTHIA, false, "pythia900Inel",
+                    "Pythia INEL");
+  gre->SetPoint(0,-3.95,1.78199);
+  gre->SetPointError(0, 0, 0, 0.0145305, 0.0145305);
+  gre->SetPoint(1,-3.85,1.85486);
+  gre->SetPointError(1,0,0,0.0148246,0.0148246);
+  gre->SetPoint(2,-3.75,1.93886);
+  gre->SetPointError(2,0,0,0.0151566,0.0151566);
+  gre->SetPoint(3,-3.65,1.96055);
+  gre->SetPointError(3,0,0,0.0152411,0.0152411);
+  gre->SetPoint(4,-3.55,1.98756);
+  gre->SetPointError(4,0,0,0.0153458,0.0153458);
+  gre->SetPoint(5,-3.45,2.02844);
+  gre->SetPointError(5,0,0,0.0155028,0.0155028);
+  gre->SetPoint(6,-3.35,2.09585);
+  gre->SetPointError(6,0,0,0.0157583,0.0157583);
+  gre->SetPoint(7,-3.25,2.13732);
+  gre->SetPointError(7,0,0,0.0159134,0.0159134);
+  gre->SetPoint(8,-3.15,2.1686);
+  gre->SetPointError(8,0,0,0.0160295,0.0160295);
+  gre->SetPoint(9,-3.05,2.25296);
+  gre->SetPointError(9,0,0,0.0163383,0.0163383);
+  gre->SetPoint(10,-2.95,2.29265);
+  gre->SetPointError(10,0,0,0.0164815,0.0164815);
+  gre->SetPoint(11,-2.85,2.34799);
+  gre->SetPointError(11,0,0,0.0166792,0.0166792);
+  gre->SetPoint(12,-2.75,2.35652);
+  gre->SetPointError(12,0,0,0.0167095,0.0167095);
+  gre->SetPoint(13,-2.65,2.40545);
+  gre->SetPointError(13,0,0,0.0168821,0.0168821);
+  gre->SetPoint(14,-2.55,2.43934);
+  gre->SetPointError(14,0,0,0.0170006,0.0170006);
+  gre->SetPoint(15,-2.45,2.45735);
+  gre->SetPointError(15,0,0,0.0170633,0.0170633);
+  gre->SetPoint(16,-2.35,2.48945);
+  gre->SetPointError(16,0,0,0.0171744,0.0171744);
+  gre->SetPoint(17,-2.25,2.51635);
+  gre->SetPointError(17,0,0,0.0172669,0.0172669);
+  gre->SetPoint(18,-2.15,2.55047);
+  gre->SetPointError(18,0,0,0.0173836,0.0173836);
+  gre->SetPoint(19,-2.05,2.58021);
+  gre->SetPointError(19,0,0,0.0174846,0.0174846);
+  gre->SetPoint(20,-1.95,2.58732);
+  gre->SetPointError(20,0,0,0.0175087,0.0175087);
+  gre->SetPoint(21,-1.85,2.60095);
+  gre->SetPointError(21,0,0,0.0175547,0.0175547);
+  gre->SetPoint(22,-1.75,2.59941);
+  gre->SetPointError(22,0,0,0.0175495,0.0175495);
+  gre->SetPoint(23,-1.65,2.63021);
+  gre->SetPointError(23,0,0,0.0176532,0.0176532);
+  gre->SetPoint(24,-1.55,2.61043);
+  gre->SetPointError(24,0,0,0.0175867,0.0175867);
+  gre->SetPoint(25,-1.45,2.61363);
+  gre->SetPointError(25,0,0,0.0175975,0.0175975);
+  gre->SetPoint(26,-1.35,2.60829);
+  gre->SetPointError(26,0,0,0.0175795,0.0175795);
+  gre->SetPoint(27,-1.25,2.61434);
+  gre->SetPointError(27,0,0,0.0175999,0.0175999);
+  gre->SetPoint(28,-1.15,2.61327);
+  gre->SetPointError(28,0,0,0.0175963,0.0175963);
+  gre->SetPoint(29,-1.05,2.57145);
+  gre->SetPointError(29,0,0,0.0174549,0.0174549);
+  gre->SetPoint(30,-0.95,2.55723);
+  gre->SetPointError(30,0,0,0.0174066,0.0174066);
+  gre->SetPoint(31,-0.85,2.57879);
+  gre->SetPointError(31,0,0,0.0174798,0.0174798);
+  gre->SetPoint(32,-0.75,2.516);
+  gre->SetPointError(32,0,0,0.0172657,0.0172657);
+  gre->SetPoint(33,-0.65,2.53709);
+  gre->SetPointError(33,0,0,0.0173379,0.0173379);
+  gre->SetPoint(34,-0.55,2.51197);
+  gre->SetPointError(34,0,0,0.0172519,0.0172519);
+  gre->SetPoint(35,-0.45,2.44052);
+  gre->SetPointError(35,0,0,0.0170047,0.0170047);
+  gre->SetPoint(36,-0.35,2.44882);
+  gre->SetPointError(36,0,0,0.0170336,0.0170336);
+  gre->SetPoint(37,-0.25,2.45308);
+  gre->SetPointError(37,0,0,0.0170484,0.0170484);
+  gre->SetPoint(38,-0.15,2.4622);
+  gre->SetPointError(38,0,0,0.0170801,0.0170801);
+  gre->SetPoint(39,-0.05,2.45735);
+  gre->SetPointError(39,0,0,0.0170633,0.0170633);
+  gre->SetPoint(40,0.05,2.49254);
+  gre->SetPointError(40,0,0,0.017185,0.017185);
+  gre->SetPoint(41,0.15,2.49479);
+  gre->SetPointError(41,0,0,0.0171928,0.0171928);
+  gre->SetPoint(42,0.25,2.49289);
+  gre->SetPointError(42,0,0,0.0171862,0.0171862);
+  gre->SetPoint(43,0.35,2.4628);
+  gre->SetPointError(43,0,0,0.0170822,0.0170822);
+  gre->SetPoint(44,0.45,2.51422);
+  gre->SetPointError(44,0,0,0.0172596,0.0172596);
+  gre->SetPoint(45,0.55,2.51268);
+  gre->SetPointError(45,0,0,0.0172543,0.0172543);
+  gre->SetPoint(46,0.65,2.51066);
+  gre->SetPointError(46,0,0,0.0172474,0.0172474);
+  gre->SetPoint(47,0.75,2.53661);
+  gre->SetPointError(47,0,0,0.0173363,0.0173363);
+  gre->SetPoint(48,0.85,2.54479);
+  gre->SetPointError(48,0,0,0.0173642,0.0173642);
+  gre->SetPoint(49,0.95,2.55391);
+  gre->SetPointError(49,0,0,0.0173953,0.0173953);
+  gre->SetPoint(50,1.05,2.5872);
+  gre->SetPointError(50,0,0,0.0175083,0.0175083);
+  gre->SetPoint(51,1.15,2.60344);
+  gre->SetPointError(51,0,0,0.0175631,0.0175631);
+  gre->SetPoint(52,1.25,2.60616);
+  gre->SetPointError(52,0,0,0.0175723,0.0175723);
+  gre->SetPoint(53,1.35,2.62156);
+  gre->SetPointError(53,0,0,0.0176242,0.0176242);
+  gre->SetPoint(54,1.45,2.61173);
+  gre->SetPointError(54,0,0,0.0175911,0.0175911);
+  gre->SetPoint(55,1.55,2.60415);
+  gre->SetPointError(55,0,0,0.0175655,0.0175655);
+  gre->SetPoint(56,1.65,2.60723);
+  gre->SetPointError(56,0,0,0.0175759,0.0175759);
+  gre->SetPoint(57,1.75,2.60427);
+  gre->SetPointError(57,0,0,0.0175659,0.0175659);
+  gre->SetPoint(58,1.85,2.56765);
+  gre->SetPointError(58,0,0,0.017442,0.017442);
+  gre->SetPoint(59,1.95,2.58602);
+  gre->SetPointError(59,0,0,0.0175043,0.0175043);
+  gre->SetPoint(60,2.05,2.55936);
+  gre->SetPointError(60,0,0,0.0174138,0.0174138);
+  gre->SetPoint(61,2.15,2.54858);
+  gre->SetPointError(61,0,0,0.0173771,0.0173771);
+  gre->SetPoint(62,2.25,2.5205);
+  gre->SetPointError(62,0,0,0.0172811,0.0172811);
+  gre->SetPoint(63,2.35,2.49491);
+  gre->SetPointError(63,0,0,0.0171932,0.0171932);
+  gre->SetPoint(64,2.45,2.42773);
+  gre->SetPointError(64,0,0,0.0169601,0.0169601);
+  gre->SetPoint(65,2.55,2.42879);
+  gre->SetPointError(65,0,0,0.0169638,0.0169638);
+  gre->SetPoint(66,2.65,2.39372);
+  gre->SetPointError(66,0,0,0.0168409,0.0168409);
+  gre->SetPoint(67,2.75,2.38412);
+  gre->SetPointError(67,0,0,0.0168071,0.0168071);
+  gre->SetPoint(68,2.85,2.31896);
+  gre->SetPointError(68,0,0,0.0165758,0.0165758);
+  gre->SetPoint(69,2.95,2.26209);
+  gre->SetPointError(69,0,0,0.0163713,0.0163713);
+  gre->SetPoint(70,3.05,2.24313);
+  gre->SetPointError(70,0,0,0.0163026,0.0163026);
+  gre->SetPoint(71,3.15,2.20403);
+  gre->SetPointError(71,0,0,0.0161599,0.0161599);
+  gre->SetPoint(72,3.25,2.12855);
+  gre->SetPointError(72,0,0,0.0158808,0.0158808);
+  gre->SetPoint(73,3.35,2.13104);
+  gre->SetPointError(73,0,0,0.01589,0.01589);
+  gre->SetPoint(74,3.45,2.06339);
+  gre->SetPointError(74,0,0,0.0156358,0.0156358);
+  gre->SetPoint(75,3.55,1.9846);
+  gre->SetPointError(75,0,0,0.0153343,0.0153343);
+  gre->SetPoint(76,3.65,1.95391);
+  gre->SetPointError(76,0,0,0.0152153,0.0152153);
+  gre->SetPoint(77,3.75,1.87998);
+  gre->SetPointError(77,0,0,0.0149247,0.0149247);
+  gre->SetPoint(78,3.85,1.86256);
+  gre->SetPointError(78,0,0,0.0148554,0.0148554);
+  gre->SetPoint(79,3.95,1.77239);
+  gre->SetPointError(79,0,0,0.0144913,0.0144913);
+  gre->SetPoint(80,4.05,1.72855);
+  gre->SetPointError(80,0,0,0.014311,0.014311);
+  gre->SetPoint(81,4.15,1.69479);
+  gre->SetPointError(81,0,0,0.0141705,0.0141705);
+  gre->SetPoint(82,4.25,1.64147);
+  gre->SetPointError(82,0,0,0.0139459,0.0139459);
+  gre->SetPoint(83,4.35,1.58116);
+  gre->SetPointError(83,0,0,0.0136873,0.0136873);
+  gre->SetPoint(84,4.45,1.55735);
+  gre->SetPointError(84,0,0,0.0135838,0.0135838);
+  gre->SetPoint(85,4.55,1.48815);
+  gre->SetPointError(85,0,0,0.0132786,0.0132786);
+  gre->SetPoint(86,4.65,1.40853);
+  gre->SetPointError(86,0,0,0.0129185,0.0129185);
+  gre->SetPoint(87,4.75,1.36979);
+  gre->SetPointError(87,0,0,0.0127396,0.0127396);
+  gre->SetPoint(88,4.85,1.32666);
+  gre->SetPointError(88,0,0,0.0125374,0.0125374);
+  gre->SetPoint(89,4.95,1.29763);
+  gre->SetPointError(89,0,0,0.0123995,0.0123995);
+  gre->SetPoint(90,5.05,1.25533);
+  gre->SetPointError(90,0,0,0.0121957,0.0121957);
+  gre->SetPoint(91,5.15,1.20912);
+  gre->SetPointError(91,0,0,0.0119692,0.0119692);
+  gre->SetPoint(92,5.25,1.18839);
+  gre->SetPointError(92,0,0,0.0118661,0.0118661);
+  gre->SetPoint(93,5.35,1.15948);
+  gre->SetPointError(93,0,0,0.0117209,0.0117209);
+  gre->SetPoint(94,5.45,1.1141);
+  gre->SetPointError(94,0,0,0.0114892,0.0114892);
+  gre->SetPoint(95,5.55,1.06315);
+  gre->SetPointError(95,0,0,0.0112235,0.0112235);
+  gre->SetPoint(96,5.65,1.05213);
+  gre->SetPointError(96,0,0,0.0111651,0.0111651);
+  gre->SetPoint(97,5.75,1.02476);
+  gre->SetPointError(97,0,0,0.011019,0.011019);
+  gre->SetPoint(98,5.85,0.984834);
+  gre->SetPointError(98,0,0,0.0108022,0.0108022);
+  gre->SetPoint(99,5.95,0.952844);
+  gre->SetPointError(99,0,0,0.0106253,0.0106253);
+
+  return gre;
+}
+
+//____________________________________________________________________
+TGraphAsymmErrors*
+Pythia900NSD()
+{
+   
+  TGraphAsymmErrors *gre = new TGraphAsymmErrors(100);
+  SetGraphAttributes(gre, NSD, PYTHIA, false, "pythia900NSD",
+                    "Pythia NSD");
+
+  gre->SetPoint(0,-3.95,2.11766);
+  gre->SetPointError(0,0,0,0.0179417,0.0179417);
+  gre->SetPoint(1,-3.85,2.20415);
+  gre->SetPointError(1,0,0,0.0183045,0.0183045);
+  gre->SetPoint(2,-3.75,2.30949);
+  gre->SetPointError(2,0,0,0.0187368,0.0187368);
+  gre->SetPoint(3,-3.65,2.34582);
+  gre->SetPointError(3,0,0,0.0188836,0.0188836);
+  gre->SetPoint(4,-3.55,2.38322);
+  gre->SetPointError(4,0,0,0.0190335,0.0190335);
+  gre->SetPoint(5,-3.45,2.43353);
+  gre->SetPointError(5,0,0,0.0192334,0.0192334);
+  gre->SetPoint(6,-3.35,2.51106);
+  gre->SetPointError(6,0,0,0.0195373,0.0195373);
+  gre->SetPoint(7,-3.25,2.56578);
+  gre->SetPointError(7,0,0,0.0197491,0.0197491);
+  gre->SetPoint(8,-3.15,2.60515);
+  gre->SetPointError(8,0,0,0.0199,0.0199);
+  gre->SetPoint(9,-3.05,2.7105);
+  gre->SetPointError(9,0,0,0.0202984,0.0202984);
+  gre->SetPoint(10,-2.95,2.77008);
+  gre->SetPointError(10,0,0,0.0205203,0.0205203);
+  gre->SetPoint(11,-2.85,2.83332);
+  gre->SetPointError(11,0,0,0.0207532,0.0207532);
+  gre->SetPoint(12,-2.75,2.84715);
+  gre->SetPointError(12,0,0,0.0208038,0.0208038);
+  gre->SetPoint(13,-2.65,2.91693);
+  gre->SetPointError(13,0,0,0.0210571,0.0210571);
+  gre->SetPoint(14,-2.55,2.95797);
+  gre->SetPointError(14,0,0,0.0212048,0.0212048);
+  gre->SetPoint(15,-2.45,2.97499);
+  gre->SetPointError(15,0,0,0.0212657,0.0212657);
+  gre->SetPoint(16,-2.35,3.01345);
+  gre->SetPointError(16,0,0,0.0214027,0.0214027);
+  gre->SetPoint(17,-2.25,3.04659);
+  gre->SetPointError(17,0,0,0.0215201,0.0215201);
+  gre->SetPoint(18,-2.15,3.09341);
+  gre->SetPointError(18,0,0,0.0216848,0.0216848);
+  gre->SetPoint(19,-2.05,3.13187);
+  gre->SetPointError(19,0,0,0.0218192,0.0218192);
+  gre->SetPoint(20,-1.95,3.13917);
+  gre->SetPointError(20,0,0,0.0218446,0.0218446);
+  gre->SetPoint(21,-1.85,3.16911);
+  gre->SetPointError(21,0,0,0.0219485,0.0219485);
+  gre->SetPoint(22,-1.75,3.15665);
+  gre->SetPointError(22,0,0,0.0219053,0.0219053);
+  gre->SetPoint(23,-1.65,3.19693);
+  gre->SetPointError(23,0,0,0.0220446,0.0220446);
+  gre->SetPoint(24,-1.55,3.17002);
+  gre->SetPointError(24,0,0,0.0219517,0.0219517);
+  gre->SetPoint(25,-1.45,3.18538);
+  gre->SetPointError(25,0,0,0.0220048,0.0220048);
+  gre->SetPoint(26,-1.35,3.18066);
+  gre->SetPointError(26,0,0,0.0219885,0.0219885);
+  gre->SetPoint(27,-1.25,3.19754);
+  gre->SetPointError(27,0,0,0.0220467,0.0220467);
+  gre->SetPoint(28,-1.15,3.18021);
+  gre->SetPointError(28,0,0,0.0219869,0.0219869);
+  gre->SetPoint(29,-1.05,3.13111);
+  gre->SetPointError(29,0,0,0.0218165,0.0218165);
+  gre->SetPoint(30,-0.95,3.12153);
+  gre->SetPointError(30,0,0,0.0217831,0.0217831);
+  gre->SetPoint(31,-0.85,3.14798);
+  gre->SetPointError(31,0,0,0.0218752,0.0218752);
+  gre->SetPoint(32,-0.75,3.07912);
+  gre->SetPointError(32,0,0,0.0216347,0.0216347);
+  gre->SetPoint(33,-0.65,3.10207);
+  gre->SetPointError(33,0,0,0.0217151,0.0217151);
+  gre->SetPoint(34,-0.55,3.06346);
+  gre->SetPointError(34,0,0,0.0215796,0.0215796);
+  gre->SetPoint(35,-0.45,2.97651);
+  gre->SetPointError(35,0,0,0.0212711,0.0212711);
+  gre->SetPoint(36,-0.35,2.98715);
+  gre->SetPointError(36,0,0,0.0213091,0.0213091);
+  gre->SetPoint(37,-0.25,2.98548);
+  gre->SetPointError(37,0,0,0.0213032,0.0213032);
+  gre->SetPoint(38,-0.15,3.00555);
+  gre->SetPointError(38,0,0,0.0213746,0.0213746);
+  gre->SetPoint(39,-0.05,3.01193);
+  gre->SetPointError(39,0,0,0.0213973,0.0213973);
+  gre->SetPoint(40,0.05,3.04385);
+  gre->SetPointError(40,0,0,0.0215104,0.0215104);
+  gre->SetPoint(41,0.15,3.04933);
+  gre->SetPointError(41,0,0,0.0215297,0.0215297);
+  gre->SetPoint(42,0.25,3.04659);
+  gre->SetPointError(42,0,0,0.0215201,0.0215201);
+  gre->SetPoint(43,0.35,3.00813);
+  gre->SetPointError(43,0,0,0.0213838,0.0213838);
+  gre->SetPoint(44,0.45,3.06666);
+  gre->SetPointError(44,0,0,0.0215908,0.0215908);
+  gre->SetPoint(45,0.55,3.07167);
+  gre->SetPointError(45,0,0,0.0216085,0.0216085);
+  gre->SetPoint(46,0.65,3.0659);
+  gre->SetPointError(46,0,0,0.0215881,0.0215881);
+  gre->SetPoint(47,0.75,3.09159);
+  gre->SetPointError(47,0,0,0.0216784,0.0216784);
+  gre->SetPoint(48,0.85,3.10846);
+  gre->SetPointError(48,0,0,0.0217375,0.0217375);
+  gre->SetPoint(49,0.95,3.11925);
+  gre->SetPointError(49,0,0,0.0217752,0.0217752);
+  gre->SetPoint(50,1.05,3.15558);
+  gre->SetPointError(50,0,0,0.0219016,0.0219016);
+  gre->SetPoint(51,1.15,3.16911);
+  gre->SetPointError(51,0,0,0.0219485,0.0219485);
+  gre->SetPoint(52,1.25,3.17246);
+  gre->SetPointError(52,0,0,0.0219601,0.0219601);
+  gre->SetPoint(53,1.35,3.19146);
+  gre->SetPointError(53,0,0,0.0220258,0.0220258);
+  gre->SetPoint(54,1.45,3.17458);
+  gre->SetPointError(54,0,0,0.0219675,0.0219675);
+  gre->SetPoint(55,1.55,3.16866);
+  gre->SetPointError(55,0,0,0.0219469,0.0219469);
+  gre->SetPoint(56,1.65,3.16592);
+  gre->SetPointError(56,0,0,0.0219375,0.0219375);
+  gre->SetPoint(57,1.75,3.16394);
+  gre->SetPointError(57,0,0,0.0219306,0.0219306);
+  gre->SetPoint(58,1.85,3.11956);
+  gre->SetPointError(58,0,0,0.0217762,0.0217762);
+  gre->SetPoint(59,1.95,3.14646);
+  gre->SetPointError(59,0,0,0.02187,0.02187);
+  gre->SetPoint(60,2.05,3.10147);
+  gre->SetPointError(60,0,0,0.021713,0.021713);
+  gre->SetPoint(61,2.15,3.09356);
+  gre->SetPointError(61,0,0,0.0216853,0.0216853);
+  gre->SetPoint(62,2.25,3.05328);
+  gre->SetPointError(62,0,0,0.0215437,0.0215437);
+  gre->SetPoint(63,2.35,3.01953);
+  gre->SetPointError(63,0,0,0.0214243,0.0214243);
+  gre->SetPoint(64,2.45,2.9373);
+  gre->SetPointError(64,0,0,0.0211305,0.0211305);
+  gre->SetPoint(65,2.55,2.92772);
+  gre->SetPointError(65,0,0,0.0210961,0.0210961);
+  gre->SetPoint(66,2.65,2.89154);
+  gre->SetPointError(66,0,0,0.0209653,0.0209653);
+  gre->SetPoint(67,2.75,2.87619);
+  gre->SetPointError(67,0,0,0.0209096,0.0209096);
+  gre->SetPoint(68,2.85,2.78924);
+  gre->SetPointError(68,0,0,0.0205911,0.0205911);
+  gre->SetPoint(69,2.95,2.72159);
+  gre->SetPointError(69,0,0,0.0203399,0.0203399);
+  gre->SetPoint(70,3.05,2.69089);
+  gre->SetPointError(70,0,0,0.0202248,0.0202248);
+  gre->SetPoint(71,3.15,2.64939);
+  gre->SetPointError(71,0,0,0.0200682,0.0200682);
+  gre->SetPoint(72,3.25,2.55545);
+  gre->SetPointError(72,0,0,0.0197092,0.0197092);
+  gre->SetPoint(73,3.35,2.56745);
+  gre->SetPointError(73,0,0,0.0197555,0.0197555);
+  gre->SetPoint(74,3.45,2.47503);
+  gre->SetPointError(74,0,0,0.0193967,0.0193967);
+  gre->SetPoint(75,3.55,2.36741);
+  gre->SetPointError(75,0,0,0.0189703,0.0189703);
+  gre->SetPoint(76,3.65,2.33412);
+  gre->SetPointError(76,0,0,0.0188364,0.0188364);
+  gre->SetPoint(77,3.75,2.2385);
+  gre->SetPointError(77,0,0,0.0184466,0.0184466);
+  gre->SetPoint(78,3.85,2.21768);
+  gre->SetPointError(78,0,0,0.0183606,0.0183606);
+  gre->SetPoint(79,3.95,2.1055);
+  gre->SetPointError(79,0,0,0.0178901,0.0178901);
+  gre->SetPoint(80,4.05,2.05047);
+  gre->SetPointError(80,0,0,0.0176548,0.0176548);
+  gre->SetPoint(81,4.15,2.00486);
+  gre->SetPointError(81,0,0,0.0174574,0.0174574);
+  gre->SetPoint(82,4.25,1.94573);
+  gre->SetPointError(82,0,0,0.017198,0.017198);
+  gre->SetPoint(83,4.35,1.87064);
+  gre->SetPointError(83,0,0,0.0168629,0.0168629);
+  gre->SetPoint(84,4.45,1.83735);
+  gre->SetPointError(84,0,0,0.0167122,0.0167122);
+  gre->SetPoint(85,4.55,1.75314);
+  gre->SetPointError(85,0,0,0.0163247,0.0163247);
+  gre->SetPoint(86,4.65,1.65828);
+  gre->SetPointError(86,0,0,0.0158769,0.0158769);
+  gre->SetPoint(87,4.75,1.60751);
+  gre->SetPointError(87,0,0,0.015632,0.015632);
+  gre->SetPoint(88,4.85,1.56312);
+  gre->SetPointError(88,0,0,0.0154146,0.0154146);
+  gre->SetPoint(89,4.95,1.52117);
+  gre->SetPointError(89,0,0,0.0152064,0.0152064);
+  gre->SetPoint(90,5.05,1.46553);
+  gre->SetPointError(90,0,0,0.0149257,0.0149257);
+  gre->SetPoint(91,5.15,1.42038);
+  gre->SetPointError(91,0,0,0.014694,0.014694);
+  gre->SetPoint(92,5.25,1.38816);
+  gre->SetPointError(92,0,0,0.0145263,0.0145263);
+  gre->SetPoint(93,5.35,1.35046);
+  gre->SetPointError(93,0,0,0.0143277,0.0143277);
+  gre->SetPoint(94,5.45,1.30075);
+  gre->SetPointError(94,0,0,0.0140616,0.0140616);
+  gre->SetPoint(95,5.55,1.24025);
+  gre->SetPointError(95,0,0,0.0137307,0.0137307);
+  gre->SetPoint(96,5.65,1.21806);
+  gre->SetPointError(96,0,0,0.0136073,0.0136073);
+  gre->SetPoint(97,5.75,1.19435);
+  gre->SetPointError(97,0,0,0.0134742,0.0134742);
+  gre->SetPoint(98,5.85,1.14175);
+  gre->SetPointError(98,0,0,0.0131741,0.0131741);
+  gre->SetPoint(99,5.95,1.09235);
+  gre->SetPointError(99,0,0,0.012886,0.012886);
+
+  return gre;
+}   
+  
 //____________________________________________________________________
 /** 
  * Get the UA5 NSD data for pp at @f$ \sqrt{s} = 900GeV@f$
@@ -672,12 +1104,14 @@ GetData(UShort_t sys,
     if (TMath::Abs(energy-900) < 10) {
       if (type & 0x1) { 
        tn.Append(" INEL");
+       if (!aliceOnly) mp->Add(Pythia900INEL());
        if (!aliceOnly) mp->Add(UA5Inel(false));
        if (!aliceOnly) mp->Add(UA5Inel(true));
        mp->Add(AliceCentralInel900());
       }      
       if (type & 0x4) { 
        tn.Append(" NSD");
+       if (!aliceOnly) mp->Add(Pythia900NSD());
        if (!aliceOnly) mp->Add(UA5Nsd(false));
        if (!aliceOnly) mp->Add(UA5Nsd(true));
        mp->Add(AliceCentralNsd900());
index 9709707..b6dbfa2 100644 (file)
@@ -1274,7 +1274,7 @@ protected:
   //__________________________________________________________________
   /** 
    * Scan directory @a dir (possibly recursive) for tree files to add
-   * to the chain.  
+   * to the chain.    This does not follow sym-links
    * 
    * @param dir        Directory to scan
    * @param chain      Chain to add to
@@ -1300,8 +1300,10 @@ protected:
     // Get list of files, and go back to old working directory
     TString oldDir(gSystem->WorkingDirectory());
     TList* files = dir->GetListOfFiles();
-    gSystem->ChangeDirectory(oldDir);
-    if (!files) return false;
+    if (!files) { 
+      gSystem->ChangeDirectory(oldDir);
+      return false;
+    }
 
     // Sort list of files and check if we should add it 
     files->Sort();
@@ -1309,16 +1311,18 @@ protected:
     TSystemFile* file = 0;
     while ((file = static_cast<TSystemFile*>(next()))) {
       TString name(file->GetName());
-    
+      TString title(file->GetTitle());
+      TString full(gSystem->ConcatFileName(file->GetTitle(), name.Data()));
       // Ignore special links 
       if (name == "." || name == "..") { 
-       Info("ScanDirectory", "Ignoring %s", name.Data());
+       // Info("ScanDirectory", "Ignoring %s", name.Data());
        continue;
       }
-      Info("ScanDirectory", "Looking at %s", name.Data());
 
+      Info("ScanDirectory", "Looking at %s", full.Data());
       // Check if this is a directory 
-      if (file->IsDirectory()) { 
+      if (file->IsDirectory(full.Data())) { 
+       Info("ScanDirectory", "%s is a directory", full.Data());
        if (recursive) {
           if (ScanDirectory(static_cast<TSystemDirectory*>(file),
                            chain,type,recursive))
@@ -1335,7 +1339,11 @@ protected:
       if (!name.EndsWith(".root")) continue;
 
       // If this file does not contain AliESDs, ignore 
-      if (!name.Contains(fnPattern)) continue;
+      if (!name.Contains(fnPattern)) { 
+       Info("ScanDirectory", "%s does not match pattern %s", 
+            name.Data(), fnPattern.Data());
+       continue;
+      }
     
       // Get the path 
       TString fn(Form("%s/%s", file->GetTitle(), name.Data()));
@@ -1345,6 +1353,7 @@ protected:
       chain->Add(fn);
       ret = true;
     }
+    gSystem->ChangeDirectory(oldDir);
     return ret;
   }
   //__________________________________________________________________
@@ -1521,7 +1530,7 @@ protected:
     Bool_t mc = mgr->GetMCtruthEventHandler() != 0;
 
     // --- Add the task ----------------------------------------------
-    gROOT->Macro(Form("AddTaskFMDEloss.C(%d)", mc, fUseCent));
+    gROOT->Macro(Form("AddTaskFMDEloss.C(%d,%d)", mc, fUseCent));
   }
   /** 
    * Crete output handler - we don't want one here.