fixing coding violations
authorkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Jul 2010 13:49:21 +0000 (13:49 +0000)
committerkleinb <kleinb@f7af4fe6-9843-0410-8265-dc069ae4e863>
Fri, 2 Jul 2010 13:49:21 +0000 (13:49 +0000)
PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.cxx
PWG4/JetTasks/AliAnalysisTaskFragmentationFunction.h

index 3aa6101..75eb5fa 100644 (file)
@@ -1009,47 +1009,47 @@ void AliAnalysisTaskFragmentationFunction::DefineJetH()
 
   farrayRadii = new Double_t[fnRBin];
 
-  Double_t Emin    = 0;
-  Double_t Emax    = 0;
+  Double_t eMin    = 0;
+  Double_t eMax    = 0;
   Double_t pasE    = (Double_t)((fEmax-fEmin)/fnEInterval);
   TString energy;
   TString energy2;
 
-  Double_t R    = 0.;
+  Double_t r    = 0.;
   Double_t pasR = (Double_t)((fRmax-fRmin)/fnRInterval);
   TString radius;
 
   for (Int_t i = 0; i < fnEBin; i++)
   {
-    Emin       = 0;
-    Emax       = 0;
+    eMin       = 0;
+    eMax       = 0;
 
-    if (i==0) Emin = fEmin;
-    if (i!=0) Emin = fEmin + pasE*i;
-    Emax = Emin+pasE;
+    if (i==0) eMin = fEmin;
+    if (i!=0) eMin = fEmin + pasE*i;
+    eMax = eMin+pasE;
     energy2 = "E_{jet1} : ";
     energy = "E_{jet} : ";
-    energy += Emin;
-    energy2 += Emin;
+    energy += eMin;
+    energy2 += eMin;
     energy += "-";
     energy2 += "-";
-    energy +=Emax;
-    energy2 += Emax;
+    energy +=eMax;
+    energy2 += eMax;
     energy += "GeV";
     energy2 += "GeV";
 
-    farrayEmin[i]      = Emin;
-    farrayEmax[i]      = Emax;
+    farrayEmin[i]      = eMin;
+    farrayEmax[i]      = eMax;
 
     for (Int_t j = 0; j < fnRBin; j++)
     {
  
-      if (j==0) R = fRmin;
-      if (j!=0) R = fRmin + pasR*j;
+      if (j==0) r = fRmin;
+      if (j!=0) r = fRmin + pasR*j;
       radius = ", R = ";
-      radius += R;    
+      radius += r;    
 
-      farrayRadii[j] = R;
+      farrayRadii[j] = r;
 
       fEtaMonoJet1H[i]   = new TH1F("fEtaMonoJet1H,"+energy, "#eta_{jet1},"+energy, fnEtaHBin, fEtaHBinMin, fEtaHBinMax);
       fPhiMonoJet1H[i]   = new TH1F("fPhiMonoJet1H,"+energy, "#phi_{jet1},"+energy, fnPhiHBin, fPhiHBinMin, fPhiHBinMax);
@@ -1349,70 +1349,3 @@ void AliAnalysisTaskFragmentationFunction::SetProperties(TH1* h,const char* x, c
 
 //////////////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////////////
-
-void AliAnalysisTaskFragmentationFunction::MakeJetContainer()
-{
-  //
-  // Create the particle container for the correction framework manager and 
-  // link it
-  //
-  const Int_t kNvar   = 3 ; //number of variables on the grid:pt,eta, phi
-  const Double_t kPtmin = 5.0, kPtmax = 105.; // we do not want to have empty bins at the beginning...
-  const Double_t kEtamin = -3.0, kEtamax = 3.0;
-  const Double_t kPhimin = 0., kPhimax = 2. * TMath::Pi();
-
-  // can we neglect migration in eta and phi?
-  // phi should be no problem since we cover full phi and are phi symmetric
-  // eta migration is more difficult  due to needed acceptance correction
-  // in limited eta range
-
-  //arrays for the number of bins in each dimension
-  Int_t iBin[kNvar];
-  iBin[0] = 100; //bins in pt
-  iBin[1] =  1; //bins in eta
-  iBin[2] = 1; // bins in phi
-
-  //arrays for lower bounds :
-  Double_t* binEdges[kNvar];
-  for(Int_t ivar = 0; ivar < kNvar; ivar++)
-    binEdges[ivar] = new Double_t[iBin[ivar] + 1];
-
-  //values for bin lower bounds
-  //  for(Int_t i=0; i<=iBin[0]; i++) binEdges[0][i]=(Double_t)TMath::Power(10,TMath::Log10(kPtmin) + (TMath::Log10(kPtmax)-TMath::Log10(kPtmin))/iBin[0]*(Double_t)i);  
-  for(Int_t i=0; i<=iBin[0]; i++) binEdges[0][i]=(Double_t)kPtmin  + (kPtmax-kPtmin)/(Double_t)iBin[0]*(Double_t)i;
-  for(Int_t i=0; i<=iBin[1]; i++) binEdges[1][i]=(Double_t)kEtamin  + (kEtamax-kEtamin)/iBin[1]*(Double_t)i;
-  for(Int_t i=0; i<=iBin[2]; i++) binEdges[2][i]=(Double_t)kPhimin  + (kPhimax-kPhimin)/iBin[2]*(Double_t)i;
-
-  /*
-  for(int i = 0;i < kMaxStep*2;++i){
-    fhnJetContainer[i] = new THnSparseF(Form("fhnJetContainer%d",i),Form("THnSparse jet info %d"),kNvar,iBin);
-    for (int k=0; k<kNvar; k++) {
-      fhnJetContainer[i]->SetBinEdges(k,binEdges[k]);
-    }
-  }
-  //create correlation matrix for unfolding
-  Int_t thnDim[2*kNvar];
-  for (int k=0; k<kNvar; k++) {
-    //first half  : reconstructed 
-    //second half : MC
-    thnDim[k]      = iBin[k];
-    thnDim[k+kNvar] = iBin[k];
-  }
-
-  fhnCorrelation = new THnSparseF("fhnCorrelation","THnSparse with correlations",2*kNvar,thnDim);
-  for (int k=0; k<kNvar; k++) {
-    fhnCorrelation->SetBinEdges(k,binEdges[k]);
-    fhnCorrelation->SetBinEdges(k+kNvar,binEdges[k]);
-  }
-  fhnCorrelation->Sumw2();
-
-  // Add a histogram for Fake jets
-  //  thnDim[3] = AliPID::kSPECIES;
-  //  fFakeElectrons = new THnSparseF("fakeEkectrons", "Output for Fake Electrons", kNvar + 1, thnDim);
-  // for(Int_t idim = 0; idim < kNvar; idim++)
-  //  fFakeElectrons->SetBinEdges(idim, binEdges[idim]);
-  */
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
index fe2afc7..22a8782 100644 (file)
@@ -4,6 +4,10 @@
 /* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
  * See cxx source for full Copyright notice                               */
  
+//
+// Task for fragmentation
+// 
+
 #include "AliAnalysisTaskSE.h"
 
 class AliJetHeader;
@@ -64,7 +68,6 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE
   AliAnalysisTaskFragmentationFunction(const AliAnalysisTaskFragmentationFunction &det);
   AliAnalysisTaskFragmentationFunction &operator=(const AliAnalysisTaskFragmentationFunction &det);
   
-  void MakeJetContainer();
  
  private:
   AliJetHeader *fJetHeaderRec;
@@ -91,157 +94,156 @@ class AliAnalysisTaskFragmentationFunction : public AliAnalysisTaskSE
   Float_t       fExternalWeight;        // external weight
   Float_t       fRecEtaWindow;          // eta window used for corraltion plots between rec and gen 
 
-  Double_t      fR;
-  Double_t      fdRdNdxi;
-  Double_t      fPartPtCut;
-  Double_t      fEfactor;
-  Int_t         fNff;
-  Int_t         fNim;
-  TList*        fList;
-
-  Int_t         fGlobVar;
+  Double_t      fR;                     // tmp
+  Double_t      fdRdNdxi;               // tmp
+  Double_t      fPartPtCut;             // tmp
+  Double_t      fEfactor;               // tmp
+  Int_t         fNff;                   // tmp
+  Int_t         fNim;                   // tmp
+  TList*        fList;                  // tmp
 
-  Bool_t        fCDFCut;
+  Int_t         fGlobVar;               // tmp
+  Bool_t        fCDFCut;                // tmp
 
   // INTERVALS
   Int_t     fnEBin;       // Number of energy bins
-  Double_t  fEmin;
-  Double_t  fEmax;
-  Int_t     fnEInterval;
+  Double_t  fEmin; // tmp
+  Double_t  fEmax; // tmp
+  Int_t     fnEInterval; // tmp
 
   Int_t     fnRBin;       // Number of radius bins
-  Double_t  fRmin;
-  Double_t  fRmax;
-  Int_t     fnRInterval;
-
+  Double_t  fRmin; // tmp
+  Double_t  fRmax; // tmp
+  Int_t     fnRInterval; // tmp
   // HISTOGRAMS LIMITS
-  Int_t     fnEtaHBin;
-  Double_t  fEtaHBinMin;
-  Double_t  fEtaHBinMax;
-
-  Int_t     fnPhiHBin;
-  Double_t  fPhiHBinMin;
-  Double_t  fPhiHBinMax;
+  Int_t     fnEtaHBin; // tmp
+  Double_t  fEtaHBinMin; // tmp
+  Double_t  fEtaHBinMax; // tmp
+  Int_t     fnPhiHBin; // tmp
+  Double_t  fPhiHBinMin; // tmp
+  Double_t  fPhiHBinMax; // tmp 
 
-  Int_t     fnPtHBin;
-  Double_t  fPtHBinMin;
-  Double_t  fPtHBinMax;
+  Int_t     fnPtHBin; // tmp
+  Double_t  fPtHBinMin; // tmp
+  Double_t  fPtHBinMax; // tmp
 
-  Int_t     fnEHBin;
-  Double_t  fEHBinMin;
-  Double_t  fEHBinMax;
+  Int_t     fnEHBin; // tmp
+  Double_t  fEHBinMin; // tmp
+  Double_t  fEHBinMax; // tmp 
 
-  Int_t     fnXiHBin;
-  Double_t  fXiHBinMax;
-  Double_t  fXiHBinMin;
+  Int_t     fnXiHBin; // tmp
+  Double_t  fXiHBinMax; // tmp
+  Double_t  fXiHBinMin; // tmp
 
-  Int_t     fnPthadHBin;
-  Double_t  fPthadHBinMin;
-  Double_t  fPthadHBinMax;
+  Int_t     fnPthadHBin; // tmp
+  Double_t  fPthadHBinMin; // tmp
+  Double_t  fPthadHBinMax; // tmp
 
-  Int_t     fnZHBin;
-  Double_t  fZHBinMin;
-  Double_t  fZHBinMax;
+  Int_t     fnZHBin; // tmp
+  Double_t  fZHBinMin; // tmp
+  Double_t  fZHBinMax; // tmp
 
-  Int_t     fnThetaHBin;
-  Double_t  fThetaHBinMin;
-  Double_t  fThetaHBinMax;
+  Int_t     fnThetaHBin; // tmp 
+  Double_t  fThetaHBinMax; // tmp
 
-  Int_t     fnCosThetaHBin;
-  Double_t  fcosThetaHBinMin;
-  Double_t  fcosThetaHBinMax;
+  Int_t     fnCosThetaHBin; // tmp
+  Double_t  fcosThetaHBinMin; // tmp
+  Double_t  fcosThetaHBinMax; // tmp
 
-  Int_t     fnkTHBin;
-  Double_t  fkTHBinMin;
-  Double_t  fkTHBinMax;
+  Int_t     fnkTHBin; // tmp
+  Double_t  fkTHBinMin; // tmp
+  Double_t  fkTHBinMax; // tmp
 
-  Int_t     fnRHBin;
-  Double_t  fRHBinMin;
-  Double_t  fRHBinMax;
+  Int_t     fnRHBin; // tmp
+  Double_t  fRHBinMin; // tmp
+  Double_t  fRHBinMax; // tmp
 
-  Int_t fnPtTrigBin;
+  Int_t fnPtTrigBin; // tmp
 
   //HISTOGRAMS
-  TH1F**        fEtaMonoJet1H;
-  TH1F**        fPhiMonoJet1H;
-  TH1F**        fPtMonoJet1H;
-  TH1F**        fEMonoJet1H;
-
-  TH1F***        fdNdXiMonoJet1H;
-  TH1F***        fdNdPtMonoJet1H;
-  TH1F***        fdNdZMonoJet1H;
-  TH1F***        fdNdThetaMonoJet1H;
-  TH1F***        fdNdcosThetaMonoJet1H;
-  TH1F***        fdNdkTMonoJet1H;
-  TH1F***        fdNdpTvsZMonoJet1H;
-  TH1F***        fShapeMonoJet1H;
-  TH1F***        fNMonoJet1sH;
-
-  TH2F***        fThetaPtPartMonoJet1H;
-  TH2F***        fcosThetaPtPartMonoJet1H;
-  TH2F***        fkTPtPartMonoJet1H;
-  TH2F***        fThetaPtJetMonoJet1H;
-  TH2F***        fcosThetaPtJetMonoJet1H;
-  TH2F***        fkTPtJetMonoJet1H;
-  TH2F***        fpTPtJetMonoJet1H;
+  TH1F**        fEtaMonoJet1H; // tmp
+  TH1F**        fPhiMonoJet1H; // tmp 
+  TH1F**        fPtMonoJet1H; // tmp
+  TH1F**        fEMonoJet1H; // tmp
+
+  TH1F***        fdNdXiMonoJet1H; // tmp
+  TH1F***        fdNdPtMonoJet1H; // tmp
+  TH1F***        fdNdZMonoJet1H; // tmp
+  TH1F***        fdNdThetaMonoJet1H; // tmp
+  TH1F***        fdNdcosThetaMonoJet1H; // tmp
+  TH1F***        fdNdkTMonoJet1H; // tmp
+  TH1F***        fdNdpTvsZMonoJet1H; // tmp
+  TH1F***        fShapeMonoJet1H; // tmp
+  TH1F***        fNMonoJet1sH; // tmp
+
+  TH2F***        fThetaPtPartMonoJet1H; // tmp
+  TH2F***        fcosThetaPtPartMonoJet1H; // tmp
+  TH2F***        fkTPtPartMonoJet1H; // tmp
+  TH2F***        fThetaPtJetMonoJet1H; // tmp
+  TH2F***        fcosThetaPtJetMonoJet1H; // tmp
+  TH2F***        fkTPtJetMonoJet1H; // tmp
+  TH2F***        fpTPtJetMonoJet1H; // tmp
 
   //ARRAYS
-  Double_t*        farrayEmin; //!
-  Double_t*        farrayEmax; //!
-  Double_t*        farrayRadii; //!
-  Double_t*        farrayPtTrigmin; //!
-  Double_t*        farrayPtTrigmax; //!
+  Double_t*        farrayEmin; //! tmp
+  Double_t*        farrayEmax; //! tmp
+  Double_t*        farrayRadii; //!  tmp
+  Double_t*        farrayPtTrigmin; //! tmp
+  Double_t*        farrayPtTrigmax; //! tmp
 
   // TRACK CONTROL PLOTS
-  TH1F* fptAllTracks; //!
-  TH1F* fetaAllTracks; //!
-  TH1F* fphiAllTracks; //!
-  TH2F* fetaphiptAllTracks; //!
-  TH2F* fetaphiAllTracks; //!
-  TH1F* fptAllTracksCut; //!
-  TH1F* fetaAllTracksCut; //!
-  TH1F* fphiAllTracksCut; //!
-  TH2F* fetaphiptAllTracksCut; //!
-  TH2F* fetaphiAllTracksCut; //!
-
-  TH1F** fptTracks; //!
-  TH1F** fetaTracks; //!
-  TH1F** fphiTracks; //!
-  TH1F** fdetaTracks; //!
-  TH1F** fdphiTracks; //!
-  TH2F** fetaphiptTracks; //!
-  TH2F** fetaphiTracks; //!
-  TH2F** fdetadphiTracks; //!
-  TH1F** fptTracksCut; //!
-  TH1F** fetaTracksCut; //!
-  TH1F** fphiTracksCut; //!
-  TH1F** fdetaTracksCut; //!
-  TH1F** fdphiTracksCut; //!
-  TH2F** fetaphiptTracksCut; //!
-  TH2F** fetaphiTracksCut; //!
-  TH2F** fdetadphiTracksCut; //!
-  TH1F** fNPtTrig;
-  TH1F** fNPtTrigCut;
-
-  TH2F* fvertexXY; //!
-  TH1F* fvertexZ; //!
-  TH1F* fEvtMult; //!
-  TH2F* fEvtMultvsJetPt; //!
-  TH2F* fPtvsEtaJet; //!
-  TH2F* fNpvsEtaJet; //!
-  TH2F* fNpevtvsEtaJet; //!
-  TH2F* fPtvsPtJet; //!
-  TH2F* fNpvsPtJet; //!
-  TH2F* fNpevtvsPtJet; //!
-  TH1F* fPtvsPtJet1D; //!
-  TH1F* fNpvsPtJet1D; //!
-  TH1F* fNpevtvsPtJet1D; //!
-  TH1F* fptLeadingJet; //!
-  TH1F* fetaLeadingJet; //!
-  TH1F* fphiLeadingJet; //!
-  TH1F* fptJet; //!
-  TH1F* fetaJet; //!
-  TH1F* fphiJet; //!
+  TH1F* fptAllTracks; //! tmp
+  TH1F* fetaAllTracks; //! tmp
+  TH1F* fphiAllTracks; //! tmp
+  TH2F* fetaphiptAllTracks; //! tmp
+  TH2F* fetaphiAllTracks; //! tmp
+  TH1F* fptAllTracksCut; //! tmp
+  TH1F* fetaAllTracksCut; //! tmp 
+  TH1F* fphiAllTracksCut; //! tmp
+  TH2F* fetaphiptAllTracksCut; //! tmp
+  TH2F* fetaphiAllTracksCut; //! tmp
+
+  TH1F** fptTracks; //! tmp
+  TH1F** fetaTracks; //! tmp
+  TH1F** fphiTracks; //!  tmp
+  TH1F** fdetaTracks; //! tmp
+  TH1F** fdphiTracks; //! tmp 
+  TH2F** fetaphiptTracks; //! tmp 
+  TH2F** fetaphiTracks; //! tmp
+  TH2F** fdetadphiTracks; //! tmp 
+  TH1F** fptTracksCut; //! tmp
+  TH1F** fetaTracksCut; //! tmp
+  TH1F** fphiTracksCut; //! tmp
+  TH1F** fdetaTracksCut; //! tmp
+  TH1F** fdphiTracksCut; //! tmp
+  TH2F** fetaphiptTracksCut; //! tmp
+  TH2F** fetaphiTracksCut; //! tmp
+  TH2F** fdetadphiTracksCut; //! tmp
+  TH1F** fNPtTrig; // tmp
+  TH1F** fNPtTrigCut; // tmp
+
+  TH2F* fvertexXY; //! tmp
+  TH1F* fvertexZ; //! tmp
+  TH1F* fEvtMult; //! tmp
+  TH2F* fEvtMultvsJetPt; //! tmp
+  TH2F* fPtvsEtaJet; //! tmp
+  TH2F* fNpvsEtaJet; //! tmp
+  TH2F* fNpevtvsEtaJet; //! tmp
+  TH2F* fPtvsPtJet; //! tmp
+  TH2F* fNpvsPtJet; //! tmp
+  TH2F* fNpevtvsPtJet; //! tmp
+  TH1F* fPtvsPtJet1D; //! tmp
+  TH1F* fNpvsPtJet1D; //! tmp
+  TH1F* fNpevtvsPtJet1D; //! tmp
+  TH1F* fptLeadingJet; //! tmp
+  TH1F* fetaLeadingJet; //! tmp
+  TH1F* fphiLeadingJet; //! // 
+  TH1F* fptJet; //! // tmp
+  TH1F* fetaJet; //! // tmp
+  TH1F* fphiJet; //! // tmp
 
 
   TList*        fHistList; //! Output list