Upgraded analysis tasks to conply with the requirements of the Analysis trains

diff --git a/FMD/analysis/AliFMDAnaParameters.cxx b/FMD/analysis/AliFMDAnaParameters.cxx
index 89ee4fc03eb4958daebf18d5f2d66c6daa102967..ed841df5da493f1f97ba96ebd647fcf007b40d52 100644 (file)
--- a/FMD/analysis/AliFMDAnaParameters.cxx
+++ b/FMD/analysis/AliFMDAnaParameters.cxx
@@ -22,9 +22,9 @@
 
 #include "AliFMDDebug.h"                  // ALILOG_H
 #include "AliFMDAnaParameters.h"          // ALIFMDPARAMETERS_H
-#include <AliCDBManager.h>         // ALICDBMANAGER_H
-#include <AliCDBEntry.h>           // ALICDBMANAGER_H
-#include "AliFMDRing.h"
+//#include <AliCDBManager.h>         // ALICDBMANAGER_H
+//#include <AliCDBEntry.h>           // ALICDBMANAGER_H
+//#include "AliFMDRing.h"
 #include <AliLog.h>
 #include <Riostream.h>
 #include <sstream>
@@ -40,7 +40,9 @@ ClassImp(AliFMDAnaParameters)
 #endif
 
 const char* AliFMDAnaParameters::fgkBackgroundCorrection  = "FMD/Correction/Background";
-const char* AliFMDAnaParameters::fgkEnergyDists  = "FMD/Correction/EnergyDistribution";
+const char* AliFMDAnaParameters::fgkEnergyDists = "FMD/Correction/EnergyDistribution";
+const char* AliFMDAnaParameters::fkBackgroundID = "background";
+const char* AliFMDAnaParameters::fkEnergyDistributionID = "energydistributions";
 //____________________________________________________________________
 AliFMDAnaParameters* AliFMDAnaParameters::fgInstance = 0;
 
@@ -58,9 +60,16 @@ AliFMDAnaParameters::Instance()
 AliFMDAnaParameters::AliFMDAnaParameters() :
   fIsInit(kFALSE),
   fBackground(0),
-  fEnergyDistribution(0)
+  fEnergyDistribution(0),
+  fCorner1(4.2231, 26.6638),
+  fCorner2(1.8357, 27.9500),
+  fEnergyPath("$ALICE_ROOT/FMD/Correction/EnergyDistribution/energydistributions.root"),
+  fBackgroundPath("$ALICE_ROOT/FMD/Correction/Background/background.root")
 {
   
+  
+  //fVerticies.Add(new TVector2(4.2231, 26.6638));
+  // fVerticies.Add(new TVector2(1.8357, 27.9500));
   // Default constructor 
 }
 //____________________________________________________________________
@@ -73,16 +82,19 @@ void AliFMDAnaParameters::Init(Bool_t forceReInit, UInt_t what)
   if (what & kBackgroundCorrection)       InitBackground();
   if (what & kEnergyDistributions)        InitEnergyDists();
   
+  
   fIsInit = kTRUE;
 }
 //____________________________________________________________________
 
 void AliFMDAnaParameters::InitBackground() {
   
-  AliCDBEntry*   background = GetEntry(fgkBackgroundCorrection);
-  if (!background) return;
+  //AliCDBEntry*   background = GetEntry(fgkBackgroundCorrection);
+  TFile* fin = TFile::Open(fBackgroundPath.Data());
+  
+  if (!fin) return;
   
-  fBackground = dynamic_cast<AliFMDAnaCalibBackgroundCorrection*>(background->GetObject());
+  fBackground = dynamic_cast<AliFMDAnaCalibBackgroundCorrection*>(fin->Get(fkBackgroundID));
   if (!fBackground) AliFatal("Invalid background object from CDB");
   
 }
@@ -90,10 +102,11 @@ void AliFMDAnaParameters::InitBackground() {
 
 void AliFMDAnaParameters::InitEnergyDists() {
   
-  AliCDBEntry*   edist = GetEntry(fgkEnergyDists);
-  if (!edist) return;
+  TFile* fin = TFile::Open(fEnergyPath.Data());
+  //AliCDBEntry*   edist = GetEntry(fgkEnergyDists);
+  if (!fin) return;
   
-  fEnergyDistribution = dynamic_cast<AliFMDAnaCalibEnergyDistribution*>(edist->GetObject());
+  fEnergyDistribution = dynamic_cast<AliFMDAnaCalibEnergyDistribution*>(fin->Get(fkEnergyDistributionID));
   
   if (!fEnergyDistribution) AliFatal("Invalid background object from CDB");
   
@@ -241,6 +254,44 @@ TH2F* AliFMDAnaParameters::GetBackgroundCorrection(Int_t det,
   return fBackground->GetBgCorrection(det,ring,vtxbin);
 }
 //_____________________________________________________________________
+Float_t AliFMDAnaParameters::GetMaxR(Char_t ring) {
+  Float_t radius = 0;
+  if(ring == 'I')
+    radius = 17.2;
+  else if(ring == 'O')
+    radius = 28.0;
+  else
+    AliWarning("Unknown ring - must be I or O!");
+  
+  return radius;
+}
+//_____________________________________________________________________
+Float_t AliFMDAnaParameters::GetMinR(Char_t ring) {
+  Float_t radius = 0;
+  if(ring == 'I')
+    radius = 4.5213;
+  else if(ring == 'O')
+    radius = 15.4;
+  else
+    AliWarning("Unknown ring - must be I or O!");
+  
+  return radius;
+
+}
+//_____________________________________________________________________
+void AliFMDAnaParameters::SetCorners(Char_t ring) {
+  
+  if(ring == 'I') {
+    fCorner1.Set(4.9895, 15.3560);
+    fCorner2.Set(1.8007, 17.2000);
+  }
+  else {
+    fCorner1.Set(4.2231, 26.6638);
+    fCorner2.Set(1.8357, 27.9500);
+  }
+  
+}
+//_____________________________________________________________________
 Float_t AliFMDAnaParameters::GetPhiFromSector(UShort_t det, Char_t ring, UShort_t sec)
 {
   Int_t nsec = (ring == 'I' ? 20 : 40);
@@ -273,11 +324,12 @@ Float_t AliFMDAnaParameters::GetPhiFromSector(UShort_t det, Char_t ring, UShort_
 //_____________________________________________________________________
 Float_t AliFMDAnaParameters::GetEtaFromStrip(UShort_t det, Char_t ring, UShort_t sec, UShort_t strip, Float_t zvtx)
 {
-  AliFMDRing fmdring(ring);
-  fmdring.Init();
-  Float_t   rad       = fmdring.GetMaxR()-fmdring.GetMinR();
-  Float_t   segment   = rad / fmdring.GetNStrips();
-  Float_t   r         = fmdring.GetMinR() + segment*strip;
+  // AliFMDRing fmdring(ring);
+  // fmdring.Init();
+  Float_t   rad       = GetMaxR(ring)-GetMinR(ring);
+  Float_t   Nstrips   = (ring == 'I' ? 512 : 256);
+  Float_t   segment   = rad / Nstrips;
+  Float_t   r         = GetMinR(ring) + segment*strip;
   Float_t   z         = 0;
   Int_t hybrid = sec / 2;
   
@@ -304,7 +356,7 @@ Float_t AliFMDAnaParameters::GetEtaFromStrip(UShort_t det, Char_t ring, UShort_t
   Float_t   eta   = -1*TMath::Log(TMath::Tan(0.5*theta));
   
   return eta;
-}
+}/*
 //____________________________________________________________________
 AliCDBEntry* AliFMDAnaParameters::GetEntry(const char* path, Bool_t fatal) const
 {
@@ -324,8 +376,69 @@ AliCDBEntry* AliFMDAnaParameters::GetEntry(const char* path, Bool_t fatal) const
   }
   return entry;
 }
-
-
+ */
+//____________________________________________________________________
+Float_t 
+AliFMDAnaParameters::GetStripLength(Char_t ring, UShort_t strip)  
+{
+  //AliFMDRing fmdring(ring);
+  // fmdring.Init();
+  
+  Float_t rad        = GetMaxR(ring)-GetMinR(ring);
+  Float_t   Nstrips   = (ring == 'I' ? 512 : 256);
+  Float_t segment    = rad / Nstrips;
+  
+  //TVector2* corner1  = fmdring.GetVertex(2);  
+  // TVector2* corner2  = fmdring.GetVertex(3);
+  
+  SetCorners(ring);
+  /*
+  std::cout<<GetMaxR(ring)<<"   "<<fmdring.GetMaxR()<<std::endl;
+  std::cout<<GetMinR(ring)<<"   "<<fmdring.GetMinR()<<std::endl;
+  std::cout<<corner1->X()<<"   "<<fCorner1.X()<<std::endl;
+  std::cout<<corner2->X()<<"   "<<fCorner2.X()<<std::endl;
+  std::cout<<corner1->Y()<<"   "<<fCorner1.Y()<<std::endl;
+  std::cout<<corner2->Y()<<"   "<<fCorner2.Y()<<std::endl;*/
+  Float_t slope      = (fCorner1.Y() - fCorner2.Y()) / (fCorner1.X() - fCorner2.X());
+  Float_t constant   = (fCorner2.Y()*fCorner1.X()-(fCorner2.X()*fCorner1.Y())) / (fCorner1.X() - fCorner2.X());
+  Float_t radius     = GetMinR(ring) + strip*segment;
+  
+  Float_t d          = TMath::Power(TMath::Abs(radius*slope),2) + TMath::Power(radius,2) - TMath::Power(constant,2);
+  
+  Float_t arclength  = GetBaseStripLength(ring,strip);
+  if(d>0) {
+    
+    Float_t x        = (-1*TMath::Sqrt(d) -slope*constant) / (1+TMath::Power(slope,2));
+    Float_t y        = slope*x + constant;
+    Float_t theta    = TMath::ATan2(x,y);
+    
+    if(x < fCorner1.X() && y > fCorner1.Y()) {
+      arclength = radius*theta;                        //One sector since theta is by definition half-hybrid
+      
+    }
+    
+  }
+  
+  return arclength;
+  
+  
+}
+//____________________________________________________________________
+Float_t 
+AliFMDAnaParameters::GetBaseStripLength(Char_t ring, UShort_t strip)  
+{  
+  // AliFMDRing fmdring(ring);
+  // fmdring.Init();
+  Float_t rad             = GetMaxR(ring)-GetMinR(ring);
+  Float_t Nstrips         = (ring == 'I' ? 512 : 256);
+  Float_t Nsec            = (ring == 'I' ? 20 : 40);
+  Float_t segment         = rad / Nstrips;
+  Float_t basearc         = 2*TMath::Pi() / (0.5*Nsec); // One hybrid: 36 degrees inner, 18 outer
+  Float_t radius          = GetMinR(ring) + strip*segment;
+  Float_t basearclength   = 0.5*basearc * radius;                // One sector   
+  
+  return basearclength;
+}
 //____________________________________________________________________
 //
 // EOF

diff --git a/FMD/analysis/AliFMDAnaParameters.h b/FMD/analysis/AliFMDAnaParameters.h
index aef53e9a72c42d01cebf7d4e96f17509feb38370..dae14d65b1ba59e2f55d9dcffc76e95236195a6d 100644 (file)
--- a/FMD/analysis/AliFMDAnaParameters.h
+++ b/FMD/analysis/AliFMDAnaParameters.h
@@ -37,6 +37,8 @@
 #include "TH1F.h"
 #include "AliFMDAnaCalibBackgroundCorrection.h"
 #include "AliFMDAnaCalibEnergyDistribution.h"
+#include <TVector2.h>
+#include <TString.h>
 //____________________________________________________________________
 //
 //  Singleton class to handle various parameters (not geometry) of the
@@ -73,6 +75,15 @@ public:
   TH2F* GetBackgroundCorrection(Int_t det, Char_t ring, Int_t vtxbin);
   Float_t GetPhiFromSector(UShort_t det, Char_t ring, UShort_t sec);
   Float_t GetEtaFromStrip(UShort_t det, Char_t ring, UShort_t sec, UShort_t strip, Float_t zvtx);
+  Float_t  GetStripLength(Char_t ring, UShort_t strip)  ;
+  Float_t  GetBaseStripLength(Char_t ring, UShort_t strip)  ;
+  Float_t  GetMaxR(Char_t ring) ;
+  Float_t  GetMinR(Char_t ring) ;
+  void     SetBackgroundPath(const Char_t* bgpath) {fBackgroundPath.Form(bgpath);}
+  void     SetEnergyPath(const Char_t* epath) {fEnergyPath.Form(epath);}
+  
+  static const char* fkBackgroundID;
+  static const char* fkEnergyDistributionID ;
 protected:
   
   AliFMDAnaParameters();
@@ -90,14 +101,14 @@ protected:
   
   static AliFMDAnaParameters* fgInstance;   // Static singleton instance
   
-  AliCDBEntry* GetEntry(const char* path, Bool_t fatal=kTRUE) const ;
+  //  AliCDBEntry* GetEntry(const char* path, Bool_t fatal=kTRUE) const ;
   void InitBackground();
   void InitEnergyDists();
   TH1F* GetEnergyDistribution(Int_t det, Char_t ring, Float_t eta);
   TObjArray* GetBackgroundArray();
   
   TAxis* GetRefAxis();
-  
+  void SetCorners(Char_t ring) ;
   
   Bool_t fIsInit;
   //TObjArray*  fBackgroundArray;
@@ -106,6 +117,12 @@ protected:
   AliFMDAnaCalibEnergyDistribution* fEnergyDistribution;
   static const char* fgkBackgroundCorrection;
   static const char* fgkEnergyDists;
+  
+  TVector2 fCorner1;
+  TVector2 fCorner2;
+  TString fEnergyPath;
+  TString fBackgroundPath;
+
   ClassDef(AliFMDAnaParameters,0) // Manager of parameters
 };
 

diff --git a/FMD/analysis/AliFMDAnalysisTaskBackgroundCorrection.cxx b/FMD/analysis/AliFMDAnalysisTaskBackgroundCorrection.cxx
index 6f70730de5e9e3ee48007e5aaf0bb54ce2034a45..285f2fc956998fa0992d130266160986a185b36e 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskBackgroundCorrection.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskBackgroundCorrection.cxx
@@ -19,7 +19,7 @@
 #include "AliESDVertex.h"
 #include "TMath.h"
 #include "AliFMDAnaParameters.h"
-#include "AliFMDGeometry.h"
+//#include "AliFMDGeometry.h"
 
 ClassImp(AliFMDAnalysisTaskBackgroundCorrection)
 
@@ -180,9 +180,10 @@ void AliFMDAnalysisTaskBackgroundCorrection::Exec(Option_t */*option*/)
       hHits->Add(hMultInput);
       TH2F* hBg        = pars->GetBackgroundCorrection(det, ringChar, vtxbin);
       
-      TH2F* hTmp       = (TH2F*)hMultInput->Clone("hMult_from_event");
+      //TH2F* hTmp       = (TH2F*)hMultInput->Clone("hMult_from_event");
+      hMultTotal->Add(hMultInput);
       
-      hTmp->Divide(hTmp,hBg,1,1);//,"B");
+      hMultTotal->Divide(hBg);//,"B");
       /*for(Int_t i = 1; i<=hTmp->GetNbinsX();i++) {
        for(Int_t j = 1; j<=hTmp->GetNbinsY();j++) {
          Float_t mult = hTmp->GetBinContent(i,j);
@@ -198,8 +199,10 @@ void AliFMDAnalysisTaskBackgroundCorrection::Exec(Option_t */*option*/)
          hTmp->SetBinContent(i,j,multcor);
        }
        }*/
-      hMultTotal->Add(hTmp);
-      delete hTmp;
+      
+      
+      
+      // delete hTmp;
       
     }
   }

diff --git a/FMD/analysis/AliFMDAnalysisTaskCollector.cxx b/FMD/analysis/AliFMDAnalysisTaskCollector.cxx
index 164cc5f36d9f5fab6bda6a20778f9502e2aef1f0..3598dd861608cea947b5f72b1f636a8ab0e9177f 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskCollector.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskCollector.cxx
@@ -17,7 +17,7 @@
 #include "AliStack.h"
 #include "AliESDVertex.h"
 #include "AliFMDAnaParameters.h"
-#include "AliFMDGeometry.h"
+//#include "AliFMDGeometry.h"
 ClassImp(AliFMDAnalysisTaskCollector)
 
 
@@ -146,17 +146,18 @@ void AliFMDAnalysisTaskCollector::Exec(Option_t */*option*/)
          
          Float_t mult = fmd->Multiplicity(det,ring,sec,strip);
          if(mult == AliESDFMD::kInvalidMult || mult == 0) continue;
-         AliFMDGeometry* geo = AliFMDGeometry::Instance();
+         //AliFMDGeometry* geo = AliFMDGeometry::Instance();
   
-         Double_t x,y,z;
-         geo->Detector2XYZ(det,ring,sec,strip,x,y,z);
+         //  Double_t x,y,z;
+         //geo->Detector2XYZ(det,ring,sec,strip,x,y,z);
          
-         Double_t r = TMath::Sqrt(x*x+y*y);
+         // Double_t r = TMath::Sqrt(x*x+y*y);
          
-         Double_t z_real      = z-vertex[2];
-         Double_t theta       = TMath::ATan2(r,z_real);
+         // Double_t z_real      = z-vertex[2];
+         // Double_t theta       = TMath::ATan2(r,z_real);
          // std::cout<<"From EtaFromStrip "<<theta<<std::endl;
-         Double_t eta         =  -1*TMath::Log(TMath::Tan(0.5*theta));
+         //Double_t eta         =  -1*TMath::Log(TMath::Tan(0.5*theta));
+         Float_t eta = pars->GetEtaFromStrip(det,ring,sec,strip,vertex[2]);
          //Float_t eta = fmd->Eta(det,ring,sec,strip);
          Int_t nEta = hBg->GetXaxis()->FindBin(eta);
          

diff --git a/FMD/analysis/AliFMDAnalysisTaskDensity.cxx b/FMD/analysis/AliFMDAnalysisTaskDensity.cxx
index da115738a2e5956349e18fb8373aa5bc2fec9394..17622861497a822d9e3193506f8eb970b5a439b0 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskDensity.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskDensity.cxx
@@ -20,9 +20,9 @@
 #include "AliESDVertex.h"
 #include "TMath.h"
 #include "AliFMDAnaParameters.h"
-#include "AliFMDParameters.h"
-#include "AliFMDGeometry.h"
-#include "AliFMDRing.h"
+//#include "AliFMDParameters.h"
+//#include "AliFMDGeometry.h"
+//#include "AliFMDRing.h"
 
 ClassImp(AliFMDAnalysisTaskDensity)
 
@@ -65,7 +65,7 @@ AliFMDAnalysisTaskDensity::AliFMDAnalysisTaskDensity(const char* name, Bool_t SE
   fFuncPos->SetParameters(0.99925,0.00298301);
   fFuncNeg = new TF1("funcNeg","pol1",-6,0);
   fFuncNeg->SetParameters(0.987583,-0.0101022);
-
+  
   
 }
 //_____________________________________________________________________
@@ -134,7 +134,7 @@ void AliFMDAnalysisTaskDensity::ConnectInputData(Option_t */*option*/)
 void AliFMDAnalysisTaskDensity::Exec(Option_t */*option*/)
 {
   AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
-  AliFMDGeometry* geo       = AliFMDGeometry::Instance();
+  // AliFMDGeometry* geo       = AliFMDGeometry::Instance();
   
   //AliESDFMD*   fmd = fESD->GetFMDData();
   
@@ -255,10 +255,12 @@ void AliFMDAnalysisTaskDensity::Exec(Option_t */*option*/)
          Float_t correction = GetAcceptanceCorrection(ring,strip);
          
          //std::cout<<"before "<<correction<<std::endl;
-         if(det == 3) 
-           correction = correction / fFuncNeg->Eval(eta);
-         else
-           correction = correction / fFuncPos->Eval(eta);
+         if(fESD->GetUniqueID() == kTRUE) {
+           if(det == 3) 
+             correction = correction / fFuncNeg->Eval(eta);
+           else
+             correction = correction / fFuncPos->Eval(eta);
+         }
          
          // std::cout<<correction<<std::endl;
          if(correction) nParticles = nParticles / correction;
@@ -277,6 +279,8 @@ void AliFMDAnalysisTaskDensity::Exec(Option_t */*option*/)
        
   
   }
+  
+
   if(fStandalone) {
     PostData(0, fOutputList); 
   }
@@ -285,18 +289,21 @@ void AliFMDAnalysisTaskDensity::Exec(Option_t */*option*/)
 //_____________________________________________________________________
 Float_t AliFMDAnalysisTaskDensity::GetAcceptanceCorrection(Char_t ring, UShort_t strip)
 {
-  AliFMDRing fmdring(ring);
-  fmdring.Init();
-  Float_t   rad       = fmdring.GetMaxR()-fmdring.GetMinR();
-  Float_t   segment   = rad / fmdring.GetNStrips();
-  Float_t   radius    = fmdring.GetMinR() + segment*strip;
+  AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
   
-  Float_t   basearea1 = 0.5*fmdring.GetBaseStripLength(strip)*TMath::Power(radius,2);
-  Float_t   basearea2 = 0.5*fmdring.GetBaseStripLength(strip)*TMath::Power((radius-segment),2);
+  //AliFMDRing fmdring(ring);
+  //fmdring.Init();
+  Float_t   rad       = pars->GetMaxR(ring)-pars->GetMinR(ring);
+  Float_t   nstrips   = (ring == 'I' ? 512 : 256);
+  Float_t   segment   = rad / nstrips;
+  Float_t   radius    = pars->GetMinR(ring) + segment*strip;
+  
+  Float_t   basearea1 = 0.5*pars->GetBaseStripLength(ring,strip)*TMath::Power(radius,2);
+  Float_t   basearea2 = 0.5*pars->GetBaseStripLength(ring,strip)*TMath::Power((radius-segment),2);
   Float_t   basearea  = basearea1 - basearea2;
   
-  Float_t   area1     = 0.5*fmdring.GetStripLength(strip)*TMath::Power(radius,2);
-  Float_t   area2     = 0.5*fmdring.GetStripLength(strip)*TMath::Power((radius-segment),2);
+  Float_t   area1     = 0.5*pars->GetStripLength(ring,strip)*TMath::Power(radius,2);
+  Float_t   area2     = 0.5*pars->GetStripLength(ring,strip)*TMath::Power((radius-segment),2);
   Float_t   area      = area1 - area2;
   
   Float_t correction = area/basearea;
@@ -304,7 +311,7 @@ Float_t AliFMDAnalysisTaskDensity::GetAcceptanceCorrection(Char_t ring, UShort_t
   return correction;
 }
 //_____________________________________________________________________
-Float_t AliFMDAnalysisTaskDensity::GetPhiFromSector(UShort_t det, Char_t ring, UShort_t sec)
+/*Float_t AliFMDAnalysisTaskDensity::GetPhiFromSector(UShort_t det, Char_t ring, UShort_t sec)
 {
   Int_t nsec = (ring == 'I' ? 20 : 40);
   Float_t basephi = 0;
@@ -334,7 +341,7 @@ Float_t AliFMDAnalysisTaskDensity::GetPhiFromSector(UShort_t det, Char_t ring, U
   return phi;
 }
 
-
+*/
 //
 //EOF
 //

diff --git a/FMD/analysis/AliFMDAnalysisTaskDndeta.cxx b/FMD/analysis/AliFMDAnalysisTaskDndeta.cxx
index b7a1693db5468df7541ee9f7e846fc2ec22ae741..13c32821944c3a3e6bb8fd3b6fe1e9184f8e37af 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskDndeta.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskDndeta.cxx
@@ -20,11 +20,11 @@
 #include "AliESDVertex.h"
 #include "TMath.h"
 #include "AliFMDAnaParameters.h"
-#include "AliFMDGeometry.h"
+//#include "AliFMDGeometry.h"
 #include "AliGenEventHeader.h"
 #include "AliHeader.h"
-#include "TDatabasePDG.h"
-#include "TParticlePDG.h"
+//#include "TDatabasePDG.h"
+//#include "TParticlePDG.h"
 #include "AliFMDStripIndex.h"
 ClassImp(AliFMDAnalysisTaskDndeta)
 
@@ -270,7 +270,7 @@ void AliFMDAnalysisTaskDndeta::ProcessPrimary() {
       AliFMDStripIndex::Unpack(ref->UserId(),det,ring,sec,strip);
       Float_t thisStripTrack = fLastTrackByStrip.operator()(det,ring,sec,strip);
       if(particle->Charge() != 0 && i != thisStripTrack ) {
-       Double_t x,y,z;
+       //Double_t x,y,z;
        /*AliFMDGeometry* fmdgeo = AliFMDGeometry::Instance();
        fmdgeo->Detector2XYZ(det,ring,sec,strip,x,y,z);
        

diff --git a/FMD/analysis/AliFMDAnalysisTaskGenerateBackground.cxx b/FMD/analysis/AliFMDAnalysisTaskGenerateBackground.cxx
index e8d081db27442754eb2595a012e2f340f0972d7e..a42b891db36ba5f99ba9ce3568c42b15dd4e0e17 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskGenerateBackground.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskGenerateBackground.cxx
@@ -10,14 +10,14 @@
 #include "AliStack.h"
 #include "AliMCParticle.h"
 #include "AliMCEvent.h"
-#include "AliFMDGeometry.h"
+//#include "AliFMDGeometry.h"
 #include "TArray.h"
 #include "AliGenEventHeader.h"
 #include "AliHeader.h"
 #include "AliFMDAnaCalibBackgroundCorrection.h"
-#include "AliCDBManager.h"
-#include "AliCDBId.h"
-#include "AliCDBMetaData.h"
+//#include "AliCDBManager.h"
+//#include "AliCDBId.h"
+//#include "AliCDBMetaData.h"
 #include "TSystem.h"
 #include "TROOT.h"
 #include "TAxis.h"
@@ -34,7 +34,7 @@ AliFMDAnalysisTaskGenerateBackground::AliFMDAnalysisTaskGenerateBackground(const
   AliAnalysisTaskSE(name),
   fZvtxCut(10),
   fNvtxBins(10),
-  fNbinsEta(100)
+  fNbinsEta(200)
 {
  
   DefineOutput(1, TList::Class());
@@ -149,15 +149,16 @@ void AliFMDAnalysisTaskGenerateBackground::UserExec(Option_t */*option*/)
       AliFMDStripIndex::Unpack(ref->UserId(),det,ring,sec,strip);
       Float_t thisStripTrack = fLastTrackByStrip.operator()(det,ring,sec,strip);
       if(particle->Charge() != 0 && i != thisStripTrack ) {
-       Double_t x,y,z;
-       AliFMDGeometry* fmdgeo = AliFMDGeometry::Instance();
-       fmdgeo->Detector2XYZ(det,ring,sec,strip,x,y,z);
-       
-       Float_t   phi   = TMath::ATan2(y,x);
-       if(phi<0) phi   = phi+2*TMath::Pi();
-       Float_t   r     = TMath::Sqrt(TMath::Power(x,2)+TMath::Power(y,2));
-       Float_t   theta = TMath::ATan2(r,z-vertex.At(2));
-       Float_t   eta   = -1*TMath::Log(TMath::Tan(0.5*theta));
+       //Double_t x,y,z;
+       //AliFMDGeometry* fmdgeo = AliFMDGeometry::Instance();
+       //fmdgeo->Detector2XYZ(det,ring,sec,strip,x,y,z);
+       Float_t phi = pars->GetPhiFromSector(det,ring,sec);
+       Float_t eta = pars->GetEtaFromStrip(det,ring,sec,strip,vertex.At(2));
+       //Float_t   phi   = TMath::ATan2(y,x);
+       //if(phi<0) phi   = phi+2*TMath::Pi();
+       //      Float_t   r     = TMath::Sqrt(TMath::Power(x,2)+TMath::Power(y,2));
+       //Float_t   theta = TMath::ATan2(r,z-vertex.At(2));
+       //Float_t   eta   = -1*TMath::Log(TMath::Tan(0.5*theta));
        TH2F* hHits = (TH2F*)fListOfHits.FindObject(Form("hHits_FMD%d%c_vtx%d", det,ring,vertexBin));
        hHits->Fill(eta,phi);
        Float_t nstrips = (ring =='O' ? 256 : 512);
@@ -196,13 +197,13 @@ void AliFMDAnalysisTaskGenerateBackground::UserExec(Option_t */*option*/)
 //_____________________________________________________________________
 void AliFMDAnalysisTaskGenerateBackground::Terminate(Option_t */*option*/)
 {
-  TH1F* allHits = (TH1F*)fListOfHits.FindObject("allHits");
+  /*  TH1F* allHits = (TH1F*)fListOfHits.FindObject("allHits");
   TH1F* doubleHits = (TH1F*)fListOfHits.FindObject("DoubleHits");
   
   doubleHits->Divide(allHits);
   GenerateCorrection();
   PostData(1, &fListOfHits);
-  PostData(4, &fListOfCorrection);
+  PostData(4, &fListOfCorrection);*/
   
 }
 //_____________________________________________________________________
@@ -277,7 +278,10 @@ void AliFMDAnalysisTaskGenerateBackground::ReadFromFile(const Char_t* filename,
   fout.Close();
   
   if(storeInOCDB) {
-    AliCDBManager* cdb = AliCDBManager::Instance();
+    TFile fcalib("$ALICE_ROOT/FMD/Correction/Background/background.root","RECREATE");
+    fBackground->Write(AliFMDAnaParameters::fkBackgroundID);
+    fcalib.Close();
+    /*  AliCDBManager* cdb = AliCDBManager::Instance();
     cdb->SetDefaultStorage("local://$ALICE_ROOT/OCDB");
     AliCDBId      id(AliFMDAnaParameters::GetBackgroundPath(),runNo,999999999);
     
@@ -288,7 +292,7 @@ void AliFMDAnalysisTaskGenerateBackground::ReadFromFile(const Char_t* filename,
     meta->SetComment("Background Correction for FMD");
     meta->SetProperty("key1", fBackground );
     cdb->Put(fBackground, id, meta);
-    
+    */
   }
   
 }

diff --git a/FMD/analysis/AliFMDAnalysisTaskSE.cxx b/FMD/analysis/AliFMDAnalysisTaskSE.cxx
index 2222046598b70793d7da3403023a0d581e3b7bcf..7a99aeb32cb3f251fe7794dab314b5c15586b96e 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskSE.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskSE.cxx
@@ -89,6 +89,7 @@ void AliFMDAnalysisTaskSE::UserExec(Option_t */*option*/)
       AliMCEvent* mcevent = MCEvent();
       fDndeta.SetMCEvent(mcevent);
       fDndeta.Exec("");
+      
     }
   }
   else

diff --git a/FMD/analysis/AliFMDAnalysisTaskSharing.cxx b/FMD/analysis/AliFMDAnalysisTaskSharing.cxx
index 901e64eb435a3f8a2cb4b8dbb90e8c2ea116d349..744630f63c557947d3ef92ba7127780285822c9e 100644 (file)
--- a/FMD/analysis/AliFMDAnalysisTaskSharing.cxx
+++ b/FMD/analysis/AliFMDAnalysisTaskSharing.cxx
@@ -7,17 +7,17 @@
 #include <TList.h>
 #include <iostream>
 #include <TMath.h>
-#include "AliFMDDebug.h"
+//#include "AliFMDDebug.h"
 #include "AliFMDAnalysisTaskSharing.h"
 #include "AliAnalysisManager.h"
 #include "AliESDFMD.h"
-#include "AliFMDGeometry.h"
+//#include "AliFMDGeometry.h"
 #include "AliMCEventHandler.h"
 #include "AliStack.h"
 #include "AliESDVertex.h"
 #include "AliMultiplicity.h"
 #include "AliFMDAnaParameters.h"
-#include "AliFMDParameters.h"
+//#include "AliFMDParameters.h"
 
 ClassImp(AliFMDAnalysisTaskSharing)
 
@@ -135,7 +135,7 @@ void AliFMDAnalysisTaskSharing::Exec(Option_t */*option*/)
   else foutputESDFMD->SetUniqueID(kFALSE);
   
   AliESDFMD* fmd = fESD->GetFMDData();
-  
+  AliFMDAnaParameters* pars = AliFMDAnaParameters::Instance();
   if (!fmd) return;
   Int_t nHits = 0;
   for(UShort_t det=1;det<=3;det++) {
@@ -159,7 +159,8 @@ void AliFMDAnalysisTaskSharing::Exec(Option_t */*option*/)
          if(mult == AliESDFMD::kInvalidMult || mult == 0) continue;
          
          //Double_t eta  = EtaFromStrip(det,ring,sec,strip,vertex[2]);//fmd->Eta(det,ring,sec,strip);
-         Double_t eta = fmd->Eta(det,ring,sec,strip);
+         //Double_t eta = fmd->Eta(det,ring,sec,strip);
+         Float_t eta = pars->GetEtaFromStrip(det,ring,sec,strip,vertex[2]);
          //std::cout<<EtaFromStrip(det,ring,sec,strip,vertex[2]) <<"    "<<fmd->Eta(det,ring,sec,strip)<<std::endl;
          
          hEdist->Fill(mult);
@@ -370,7 +371,7 @@ Float_t AliFMDAnalysisTaskSharing::Eta2Theta(Float_t eta) {
 
 }
 //_____________________________________________________________________
-Double_t AliFMDAnalysisTaskSharing::EtaFromStrip(UShort_t det, 
+/*Double_t AliFMDAnalysisTaskSharing::EtaFromStrip(UShort_t det, 
                                                Char_t ring, 
                                                UShort_t sector, 
                                                UShort_t strip, 
@@ -392,7 +393,7 @@ Double_t AliFMDAnalysisTaskSharing::EtaFromStrip(UShort_t det,
   // std::cout<<det<<"   "<<ring<<"   "<<sector<<"   "<<strip<<"   "<<r<<"    "<<z_real<<"   "<<theta<<"    "<<eta<<std::endl;
   
   return eta;
-}
+  }*/
 //_____________________________________________________________________
 //
 // EOF