// Set the lower multiplicity cut. Overrides setting in energy loss fits.
task->GetDensityCalculator().SetMultCut(0.3);
// Whether to use the merging efficiency correction
- task->GetCorrections().UseMergingEfficiency(false);
+ task->GetCorrections().SetUseMergingEfficiency(false);
// Set the number of extra bins (beyond the secondary map border)
task->GetHistCollector().SetNCutBins(2);
// Set the correction cut, that is, when bins in the secondary map
}
return kTRUE;
}
+//____________________________________________________________________
+AliFMDCorrELossFit::ELossFit*
+AliFMDCorrELossFit::GetFit(UShort_t d, Char_t r, Int_t etabin) const
+{
+ //
+ // Get the fit corresponding to the specified parameters
+ //
+ // Parameters:
+ // d Detector
+ // r Ring
+ // etabin Eta bin (1 based)
+ //
+ // Return:
+ // Fit parameters or null in case of problems
+ //
+ TObjArray* ringArray = GetRingArray(d, r);
+ if (!ringArray) return 0;
+ if (etabin <= 0 || etabin >= fEtaAxis.GetNbins()) return 0;
+ if (etabin > ringArray->GetEntriesFast()) return 0;
+ else if (etabin >= ringArray->GetEntriesFast()) etabin--;
+ else if (!ringArray->At(etabin)) etabin++;
+ return static_cast<ELossFit*>(ringArray->At(etabin));
+}
+//____________________________________________________________________
+AliFMDCorrELossFit::ELossFit*
+AliFMDCorrELossFit::GetFit(UShort_t d, Char_t r, Double_t eta) const
+{
+ //
+ // Find the fit corresponding to the specified parameters
+ //
+ // Parameters:
+ // d Detector
+ // r Ring
+ // eta Eta value
+ //
+ // Return:
+ // Fit parameters or null in case of problems
+ //
+ Int_t etabin = FindEtaBin(eta);
+ return GetFit(d, r, etabin);
+}
+
//____________________________________________________________________
AliFMDCorrELossFit::ELossFit*
AliFMDCorrELossFit::FindFit(UShort_t d, Char_t r, Int_t etabin) const
* @return Fit parameters or null in case of problems
*/
ELossFit* FindFit(UShort_t d, Char_t r, Int_t etabin) const;
+ /**
+ * Find the fit corresponding to the specified parameters
+ *
+ * @param d Detector
+ * @param r Ring
+ * @param eta Eta value
+ *
+ * @return Fit parameters or null in case of problems
+ */
+ ELossFit* GetFit(UShort_t d, Char_t r, Double_t eta) const;
+ /**
+ * Find the fit corresponding to the specified parameters
+ *
+ * @param d Detector
+ * @param r Ring
+ * @param etabin Eta bin (1 based)
+ *
+ * @return Fit parameters or null in case of problems
+ */
+ ELossFit* GetFit(UShort_t d, Char_t r, Int_t etabin) const;
/* @} */
/**
* @param dbg Debug level
*/
void SetDebug(Int_t dbg=1) { fDebug = dbg; }
- void UseMergingEfficiency(Bool_t use=true) { fUseMergingEfficiency = use; }
+ /**
+ * Whether to use the merging efficiency correction
+ *
+ * @param use If true, use the merging efficiency correction
+ */
+ void SetUseMergingEfficiency(Bool_t use=true) { fUseMergingEfficiency = use; }
+ /**
+ * Check
+ *
+ * @return true if the merging efficiency correction is used.
+ */
+ Bool_t IsUseMergingEfficiency() const { return fUseMergingEfficiency; }
/**
* Print information
*
fMaxParticles(5),
fAccI(0),
fAccO(0),
+ fFMD1iMax(0),
+ fFMD2iMax(0),
+ fFMD2oMax(0),
+ fFMD3iMax(0),
+ fFMD3oMax(0),
fDebug(0)
{
//
fMaxParticles(5),
fAccI(0),
fAccO(0),
+ fFMD1iMax(0),
+ fFMD2iMax(0),
+ fFMD2oMax(0),
+ fFMD3iMax(0),
+ fFMD3oMax(0),
fDebug(0)
{
//
fMaxParticles(o.fMaxParticles),
fAccI(o.fAccI),
fAccO(o.fAccO),
+ fFMD1iMax(o.fFMD1iMax),
+ fFMD2iMax(o.fFMD2iMax),
+ fFMD2oMax(o.fFMD2oMax),
+ fFMD3iMax(o.fFMD3iMax),
+ fFMD3oMax(o.fFMD3oMax),
fDebug(o.fDebug)
{
//
fMaxParticles = o.fMaxParticles;
fAccI = o.fAccI;
fAccO = o.fAccO;
+ fFMD1iMax = o.fFMD1iMax;
+ fFMD2iMax = o.fFMD2iMax;
+ fFMD2oMax = o.fFMD2oMax;
+ fFMD3iMax = o.fFMD3iMax;
+ fFMD3oMax = o.fFMD3oMax;
fRingHistos.Delete();
TIter next(&o.fRingHistos);
return *this;
}
+//____________________________________________________________________
+void
+AliFMDDensityCalculator::Init(const TAxis&)
+{
+ // Intialize this sub-algorithm
+ //
+ // Parameters:
+ // etaAxis Not used
+ CacheMaxWeights();
+}
+
//____________________________________________________________________
AliFMDDensityCalculator::RingHistos*
AliFMDDensityCalculator::GetRingHistos(UShort_t d, Char_t r) const
return kTRUE;
}
+//_____________________________________________________________________
+Int_t
+AliFMDDensityCalculator::FindMaxWeight(AliFMDCorrELossFit* cor,
+ UShort_t d, Char_t r, Int_t iEta) const
+{
+ 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));
+ return -1;
+ }
+ return fit->FindMaxWeight();
+}
+
+//_____________________________________________________________________
+void
+AliFMDDensityCalculator::CacheMaxWeights()
+{
+ AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
+ AliFMDCorrELossFit* cor = fcm.GetELossFit();
+ const TAxis& eta = cor->GetEtaAxis();
+
+ Int_t nEta = eta.GetNbins();
+ fFMD1iMax.Set(nEta);
+ fFMD2iMax.Set(nEta);
+ fFMD2oMax.Set(nEta);
+ fFMD3iMax.Set(nEta);
+ fFMD3oMax.Set(nEta);
+
+ for (Int_t i = 0; i < nEta; i++) {
+ fFMD1iMax[i] = FindMaxWeight(cor, 1, 'I', i+1);
+ fFMD2iMax[i] = FindMaxWeight(cor, 2, 'I', i+1);
+ fFMD2oMax[i] = FindMaxWeight(cor, 2, 'O', i+1);
+ fFMD3iMax[i] = FindMaxWeight(cor, 3, 'I', i+1);
+ fFMD3oMax[i] = FindMaxWeight(cor, 3, 'O', i+1);
+ }
+}
+
+//_____________________________________________________________________
+Int_t
+AliFMDDensityCalculator::GetMaxWeight(UShort_t d, Char_t r, Int_t iEta) const
+{
+ if (iEta < 0) return -1;
+
+ const TArrayI* max = 0;
+ switch (d) {
+ case 1: max = &fFMD1iMax; break;
+ case 2: max = (r == 'I' || r == 'i' ? &fFMD2iMax : &fFMD2oMax); break;
+ case 3: max = (r == 'I' || r == 'i' ? &fFMD3iMax : &fFMD3oMax); break;
+ }
+ if (!max) {
+ AliWarning(Form("No array for FMD%d%c", d, r));
+ return -1;
+ }
+
+ if (iEta >= max->fN) {
+ AliWarning(Form("Eta bin %3d out of bounds [0,%d]",
+ iEta, max->fN-1));
+ return -1;
+ }
+
+ AliDebug(30,Form("Max weight for FMD%d%c eta bin %3d: %d", d, r, iEta,
+ max->At(iEta)));
+ return max->At(iEta);
+}
+
+//_____________________________________________________________________
+Int_t
+AliFMDDensityCalculator::GetMaxWeight(UShort_t d, Char_t r, Float_t eta) const
+{
+ AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
+ Int_t iEta = fcm.GetELossFit()->FindEtaBin(eta) -1;
+
+ return GetMaxWeight(d, r, iEta);
+}
+
//_____________________________________________________________________
Float_t
AliFMDDensityCalculator::NParticles(Float_t mult,
return 0;
}
- Int_t m = fit->FindMaxWeight();
+ Int_t m = GetMaxWeight(d,r,eta); // fit->FindMaxWeight();
if (m < 1) {
AliWarning(Form("No good fits for FMD%d%c at eta=%f", d, r, eta));
return 0;
if (fDebug > 10) {
AliInfo(Form("FMD%d%c, eta=%7.4f, %8.5f -> %8.5f", d, r, eta, mult, ret));
}
-
+
fWeightedSum->Fill(ret);
fSumOfWeights->Fill(ret);
}
//____________________________________________________________________
void
-AliFMDDensityCalculator::Print(Option_t*) const
+AliFMDDensityCalculator::Print(Option_t* option) const
{
//
// Print information
// Parameters:
// option Not used
//
- char ind[gROOT->GetDirLevel()+1];
+ char ind[gROOT->GetDirLevel()+3];
for (Int_t i = 0; i < gROOT->GetDirLevel(); i++) ind[i] = ' ';
ind[gROOT->GetDirLevel()] = '\0';
std::cout << ind << "AliFMDDensityCalculator: " << GetName() << '\n'
<< ind << " Multiplicity cut: " << fMultCut << '\n'
<< ind << " Max(particles): " << fMaxParticles
<< std::endl;
+ TString opt(option);
+ opt.ToLower();
+ if (opt.Contains("nomax")) return;
+
+ std::cout << ind << " Max weights:\n";
+
+ for (UShort_t d=1; d<=3; d++) {
+ UShort_t nr = (d == 1 ? 1 : 2);
+ for (UShort_t q=0; q<nr; q++) {
+ ind[gROOT->GetDirLevel()] = ' ';
+ ind[gROOT->GetDirLevel()+1] = '\0';
+ Char_t r = (q == 0 ? 'I' : 'O');
+ std::cout << ind << " FMD" << d << r << ":";
+ ind[gROOT->GetDirLevel()+1] = ' ';
+ ind[gROOT->GetDirLevel()+2] = '\0';
+
+ const TArrayI& a = (d == 1 ? fFMD1iMax :
+ (d == 2 ? (r == 'I' ? fFMD2iMax : fFMD2oMax) :
+ (r == 'I' ? fFMD3iMax : fFMD3oMax)));
+ Int_t j = 0;
+ for (Int_t i = 0; i < a.fN; i++) {
+ if (a.fArray[i] < 1) continue;
+ if (j % 6 == 0) std::cout << "\n " << ind;
+ j++;
+ std::cout << " " << std::setw(3) << i << ": " << a.fArray[i];
+ }
+ std::cout << std::endl;
+ }
+ }
}
//====================================================================
#define ALIFMDDENSITYCALCULATOR_H
#include <TNamed.h>
#include <TList.h>
+#include <TArrayI.h>
#include "AliForwardUtil.h"
class AliESDFMD;
class TH2D;
class TH1D;
class TProfile;
+class AliFMDCorrELossFit;
/**
* This class calculates the inclusive charged particle density
* @return Reference to this object
*/
AliFMDDensityCalculator& operator=(const AliFMDDensityCalculator& o);
+ /**
+ * Initialize this sub-algorithm
+ *
+ * @param etaAxis Not used
+ */
+ virtual void Init(const TAxis& etaAxis);
/**
* Do the calculations
*
/**
* Print information
*
- * @param option Not used
+ * @param option Print options
+ * - max Print max weights
*/
void Print(Option_t* option="") const;
protected:
+ /**
+ * Find the max weight to use for FMD<i>dr</i> in eta bin @a iEta
+ *
+ * @param cor Correction
+ * @param d Detector
+ * @param r Ring
+ * @param iEta Eta bin
+ */
+ Int_t FindMaxWeight(AliFMDCorrELossFit* cor,
+ UShort_t d, Char_t r, Int_t iEta) const;
+
+ /**
+ * Find the max weights and cache them
+ *
+ */
+ void CacheMaxWeights();
+ /**
+ * Find the (cached) maximum weight for FMD<i>dr</i> in
+ * @f$\eta@f$ bin @a iEta
+ *
+ * @param d Detector
+ * @param r Ring
+ * @param iEta Eta bin
+ *
+ * @return max weight or <= 0 in case of problems
+ */
+ Int_t GetMaxWeight(UShort_t d, Char_t r, Int_t iEta) const;
+ /**
+ * Find the (cached) maximum weight for FMD<i>dr</i> iat
+ * @f$\eta@f$
+ *
+ * @param d Detector
+ * @param r Ring
+ * @param eta Eta bin
+ *
+ * @return max weight or <= 0 in case of problems
+ */
+ Int_t GetMaxWeight(UShort_t d, Char_t r, Float_t eta) const;
+
/**
* Get the number of particles corresponding to the signal mult
*
TList fRingHistos; // List of histogram containers
Double_t fMultCut; // Low cut on scaled energy loss
- TH1D* fSumOfWeights; //! Histogram
- TH1D* fWeightedSum; //! Histogram
- TH1D* fCorrections; //! Histogram
+ TH1D* fSumOfWeights; // Histogram
+ TH1D* fWeightedSum; // Histogram
+ TH1D* fCorrections; // Histogram
UShort_t fMaxParticles; // Maximum particle weight to use
TH1D* fAccI; // Acceptance correction for inner rings
TH1D* fAccO; // Acceptance correction for outer rings
+ TArrayI fFMD1iMax; // Array of max weights
+ TArrayI fFMD2iMax; // Array of max weights
+ TArrayI fFMD2oMax; // Array of max weights
+ TArrayI fFMD3iMax; // Array of max weights
+ TArrayI fFMD3oMax; // Array of max weights
Int_t fDebug; // Debug level
ClassDef(AliFMDDensityCalculator,1); // Calculate Nch density
// Parameters:
// title Title of object - not significant
//
- fFMD1i = new TH2D("FMD1i_corr", "Merged vs MC", 21, -.5, 20.5, 100, 0, 20);
- fFMD2i = new TH2D("FMD2i_corr", "Merged vs MC", 21, -.5, 20.5, 100, 0, 20);
- fFMD2o = new TH2D("FMD2o_corr", "Merged vs MC", 21, -.5, 20.5, 100, 0, 20);
- fFMD3i = new TH2D("FMD3i_corr", "Merged vs MC", 21, -.5, 20.5, 100, 0, 20);
- fFMD3o = new TH2D("FMD3o_corr", "Merged vs MC", 21, -.5, 20.5, 100, 0, 20);
+ fFMD1i = new TH2D("FMD1i_corr", "Merged vs MC", 21, -.5, 20.5, 300, 0, 15);
+ fFMD2i = new TH2D("FMD2i_corr", "Merged vs MC", 21, -.5, 20.5, 300, 0, 15);
+ fFMD2o = new TH2D("FMD2o_corr", "Merged vs MC", 21, -.5, 20.5, 300, 0, 15);
+ fFMD3i = new TH2D("FMD3i_corr", "Merged vs MC", 21, -.5, 20.5, 300, 0, 15);
+ fFMD3o = new TH2D("FMD3o_corr", "Merged vs MC", 21, -.5, 20.5, 300, 0, 15);
fFMD1i->SetYTitle("#Delta E/#Delta_{mip} (ESD)");
fFMD1i->SetXTitle("Hits (MC)");
fFMD2i->SetYTitle("#Delta E/#Delta_{mip} (ESD)");
// Initialise the sub objects and stuff. Called on first event
//
//
+ UInt_t what = AliForwardCorrectionManager::kAll;
+ if (!fEnableLowFlux)
+ what ^= AliForwardCorrectionManager::kDoubleHit;
+ if (!fCorrections.IsUseMergingEfficiency())
+ what ^= AliForwardCorrectionManager::kMergingEfficiency;
+
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
fcm.Init(fEventInspector.GetCollisionSystem(),
fEventInspector.GetEnergy(),
- fEventInspector.GetField(),
- true); // Last true is for MC flag
- // Check that we have the energy loss fits, needed by
- // AliFMDSharingFilter
- // AliFMDDensityCalculator
- if (!fcm.GetELossFit()) {
- AliFatal(Form("No energy loss fits"));
- return;
- }
- // Check that we have the double hit correction - (optionally) used by
- // AliFMDDensityCalculator
- if (!fcm.GetDoubleHit()) {
- AliWarning("No double hit corrections");
- }
- // Check that we have the secondary maps, needed by
- // AliFMDCorrections
- // AliFMDHistCollector
- if (!fcm.GetSecondaryMap()) {
- AliFatal("No secondary corrections");
- return;
- }
- // Check that we have the vertex bias correction, needed by
- // AliFMDCorrections
- if (!fcm.GetVertexBias()) {
- AliFatal("No event vertex bias corrections");
- return;
- }
- // Check that we have the merging efficiencies, optionally used by
- // AliFMDCorrections
- if (!fcm.GetMergingEfficiency()) {
- AliWarning("No merging efficiencies");
- }
-
+ fEventInspector.GetField(),
+ true,
+ what);
+ if (!CheckCorrections(what)) return;
const TAxis* pe = fcm.GetEtaAxis();
const TAxis* pv = fcm.GetVertexAxis();
fCorrections.ScaleHistograms(list,hEventsTrVtx->Integral());
}
-//____________________________________________________________________
-void
-AliForwardMCMultiplicityTask::Print(Option_t* option) const
-{
- //
- // Print information
- //
- // Parameters:
- // option Not used
- //
- AliForwardMultiplicityBase::Print(option);
- gROOT->IncreaseDirLevel();
- fEventInspector .Print(option);
- fEnergyFitter .Print(option);
- fSharingFilter .Print(option);
- fDensityCalculator.Print(option);
- fCorrections .Print(option);
- fHistCollector .Print(option);
- gROOT->DecreaseDirLevel();
-}
//
// EOF
/**
* @}
*/
- /**
- * Print information
- *
- * @param option Not used
- */
- void Print(Option_t* option="") const;
/**
* @{
* @name Access to sub-algorithms
* @return Reference to AliFMDHistCollector object
*/
AliFMDHistCollector& GetHistCollector() { return fHistCollector; }
+ /**
+ * Get reference to the EventInspector algorithm
+ *
+ * @return Reference to AliFMDEventInspector object
+ */
+ const AliFMDEventInspector& GetEventInspector() const { return fEventInspector; }
+ /**
+ * Get reference to the EnergyFitter algorithm
+ *
+ * @return Reference to AliFMDEnergyFitter object
+ */
+ const AliFMDEnergyFitter& GetEnergyFitter() const { return fEnergyFitter; }
+ /**
+ * Get reference to the SharingFilter algorithm
+ *
+ * @return Reference to AliFMDSharingFilter object
+ */
+ const AliFMDSharingFilter& GetSharingFilter() const { return fSharingFilter; }
+ /**
+ * Get reference to the DensityCalculator algorithm
+ *
+ * @return Reference to AliFMDDensityCalculator object
+ */
+ const AliFMDDensityCalculator& GetDensityCalculator() const { return fDensityCalculator; }
+ /**
+ * Get reference to the Corrections algorithm
+ *
+ * @return Reference to AliFMDCorrections object
+ */
+ const AliFMDCorrections& GetCorrections() const { return fCorrections; }
+ /**
+ * Get reference to the HistCollector algorithm
+ *
+ * @return Reference to AliFMDHistCollector object
+ */
+ const AliFMDHistCollector& GetHistCollector() const { return fHistCollector; }
/**
* @}
*/
//
// Corrections used
#include "AliForwardMultiplicityBase.h"
+#include "AliForwardCorrectionManager.h"
#include "AliLog.h"
#include "AliAODHandler.h"
#include "AliInputEventHandler.h"
#include "AliAnalysisManager.h"
+#include "AliFMDEventInspector.h"
+#include "AliFMDEnergyFitter.h"
+#include "AliFMDSharingFilter.h"
+#include "AliFMDDensityCalculator.h"
+#include "AliFMDCorrections.h"
+#include "AliFMDHistCollector.h"
#include <TROOT.h>
#include <iostream>
#include <iomanip>
//====================================================================
+Bool_t
+AliForwardMultiplicityBase::CheckCorrections(UInt_t what) const
+{
+ //
+ // Check if all needed corrections are there and accounted for. If not,
+ // do a Fatal exit
+ //
+ // Parameters:
+ // what Which corrections is needed
+ //
+ // Return:
+ // true if all present, false otherwise
+ //
+
+ AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
+ // Check that we have the energy loss fits, needed by
+ // AliFMDSharingFilter
+ // AliFMDDensityCalculator
+ if (what & AliForwardCorrectionManager::kELossFits && !fcm.GetELossFit()) {
+ AliFatal(Form("No energy loss fits"));
+ return false;
+ }
+ // Check that we have the double hit correction - (optionally) used by
+ // AliFMDDensityCalculator
+ if (what & AliForwardCorrectionManager::kDoubleHit && !fcm.GetDoubleHit()) {
+ AliFatal("No double hit corrections");
+ return false;
+ }
+ // Check that we have the secondary maps, needed by
+ // AliFMDCorrections
+ // AliFMDHistCollector
+ if (what & AliForwardCorrectionManager::kSecondaryMap &&
+ !fcm.GetSecondaryMap()) {
+ AliFatal("No secondary corrections");
+ return false;
+ }
+ // Check that we have the vertex bias correction, needed by
+ // AliFMDCorrections
+ if (what & AliForwardCorrectionManager::kVertexBias &&
+ !fcm.GetVertexBias()) {
+ AliFatal("No event vertex bias corrections");
+ return false;
+ }
+ // Check that we have the merging efficiencies, optionally used by
+ // AliFMDCorrections
+ if (what & AliForwardCorrectionManager::kMergingEfficiency &&
+ !fcm.GetMergingEfficiency()) {
+ AliFatal("No merging efficiencies");
+ return false;
+ }
+ return true;
+}
+
+//____________________________________________________________________
void
AliForwardMultiplicityBase::MarkEventForStore() const
{
std::cout << "AliForwardMultiplicityBase: " << GetName() << "\n"
<< " Enable low flux code: " << (fEnableLowFlux ? "yes" : "no")
<< std::endl;
+ gROOT->IncreaseDirLevel();
+ GetEventInspector() .Print(option);
+ GetEnergyFitter() .Print(option);
+ GetSharingFilter() .Print(option);
+ GetDensityCalculator().Print(option);
+ GetCorrections() .Print(option);
+ GetHistCollector() .Print(option);
+ gROOT->DecreaseDirLevel();
}
+
//
// EOF
//
* @return Reference to AliFMDHistCollector object
*/
virtual AliFMDHistCollector& GetHistCollector() = 0;
+ /**
+ * Get reference to the EventInspector algorithm
+ *
+ * @return Reference to AliFMDEventInspector object
+ */
+ virtual const AliFMDEventInspector& GetEventInspector() const = 0;
+ /**
+ * Get reference to the EnergyFitter algorithm
+ *
+ * @return Reference to AliFMDEnergyFitter object
+ */
+ virtual const AliFMDEnergyFitter& GetEnergyFitter() const = 0;
+ /**
+ * Get reference to the SharingFilter algorithm
+ *
+ * @return Reference to AliFMDSharingFilter object
+ */
+ virtual const AliFMDSharingFilter& GetSharingFilter() const = 0;
+ /**
+ * Get reference to the DensityCalculator algorithm
+ *
+ * @return Reference to AliFMDDensityCalculator object
+ */
+ virtual const AliFMDDensityCalculator& GetDensityCalculator() const = 0;
+ /**
+ * Get reference to the Corrections algorithm
+ *
+ * @return Reference to AliFMDCorrections object
+ */
+ virtual const AliFMDCorrections& GetCorrections() const = 0;
+ /**
+ * Get reference to the HistCollector algorithm
+ *
+ * @return Reference to AliFMDHistCollector object
+ */
+ virtual const AliFMDHistCollector& GetHistCollector() const = 0;
/**
* @}
*/
fFirstEvent = o.fFirstEvent;
return *this;
}
+ /**
+ * Check if all needed corrections are there and accounted for. If not,
+ * do a Fatal exit
+ *
+ * @param what Which corrections is needed
+ *
+ * @return true if all present, false otherwise
+ */
+ Bool_t CheckCorrections(UInt_t what) const;
/**
* Mark this event as one to store in the AOD
*
// Initialise the sub objects and stuff. Called on first event
//
//
+ UInt_t what = AliForwardCorrectionManager::kAll;
+ if (!fEnableLowFlux)
+ what ^= AliForwardCorrectionManager::kDoubleHit;
+ if (!fCorrections.IsUseMergingEfficiency())
+ what ^= AliForwardCorrectionManager::kMergingEfficiency;
+
AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
fcm.Init(fEventInspector.GetCollisionSystem(),
fEventInspector.GetEnergy(),
- fEventInspector.GetField());
- // Check that we have the energy loss fits, needed by
- // AliFMDSharingFilter
- // AliFMDDensityCalculator
- if (!fcm.GetELossFit()) {
- AliFatal(Form("No energy loss fits"));
- return;
- }
- // Check that we have the double hit correction - (optionally) used by
- // AliFMDDensityCalculator
- if (!fcm.GetDoubleHit()) {
- AliWarning("No double hit corrections");
- }
- // Check that we have the secondary maps, needed by
- // AliFMDCorrections
- // AliFMDHistCollector
- if (!fcm.GetSecondaryMap()) {
- AliFatal("No secondary corrections");
- return;
- }
- // Check that we have the vertex bias correction, needed by
- // AliFMDCorrections
- if (!fcm.GetVertexBias()) {
- AliFatal("No event vertex bias corrections");
- return;
- }
- // Check that we have the merging efficiencies, optionally used by
- // AliFMDCorrections
- if (!fcm.GetMergingEfficiency()) {
- AliWarning("No merging efficiencies");
- }
+ fEventInspector.GetField(),
+ false,
+ what);
+ if (!CheckCorrections(what)) return;
const TAxis* pe = fcm.GetEtaAxis();
fEnergyFitter.Init(*pe);
fEventInspector.Init(*pv);
+ fDensityCalculator.Init(*pe);
fHistCollector.Init(*pv);
this->Print();
fDensityCalculator.ScaleHistograms(list,hEventsTrVtx->Integral());
fCorrections.ScaleHistograms(list,hEventsTrVtx->Integral());
}
-//____________________________________________________________________
-void
-AliForwardMultiplicityTask::Print(Option_t* option) const
-{
- //
- // Print information
- //
- // Parameters:
- // option Not used
- //
- AliForwardMultiplicityBase::Print(option);
- gROOT->IncreaseDirLevel();
- fEventInspector .Print(option);
- fEnergyFitter .Print(option);
- fSharingFilter .Print(option);
- fDensityCalculator.Print(option);
- fCorrections .Print(option);
- fHistCollector .Print(option);
- gROOT->DecreaseDirLevel();
-}
//
// EOF
/**
* @}
*/
- /**
- * Print information
- *
- * @param option Not used
- */
- void Print(Option_t* option="") const;
/**
* @{
* @name Access to sub-algorithms
* @return Reference to AliFMDHistCollector object
*/
AliFMDHistCollector& GetHistCollector() { return fHistCollector; }
+ /**
+ * Get reference to the EventInspector algorithm
+ *
+ * @return Reference to AliFMDEventInspector object
+ */
+ const AliFMDEventInspector& GetEventInspector() const { return fEventInspector; }
+ /**
+ * Get reference to the EnergyFitter algorithm
+ *
+ * @return Reference to AliFMDEnergyFitter object
+ */
+ const AliFMDEnergyFitter& GetEnergyFitter() const { return fEnergyFitter; }
+ /**
+ * Get reference to the SharingFilter algorithm
+ *
+ * @return Reference to AliFMDSharingFilter object
+ */
+ const AliFMDSharingFilter& GetSharingFilter() const { return fSharingFilter; }
+ /**
+ * Get reference to the DensityCalculator algorithm
+ *
+ * @return Reference to AliFMDDensityCalculator object
+ */
+ const AliFMDDensityCalculator& GetDensityCalculator() const { return fDensityCalculator; }
+ /**
+ * Get reference to the Corrections algorithm
+ *
+ * @return Reference to AliFMDCorrections object
+ */
+ const AliFMDCorrections& GetCorrections() const { return fCorrections; }
+ /**
+ * Get reference to the HistCollector algorithm
+ *
+ * @return Reference to AliFMDHistCollector object
+ */
+ const AliFMDHistCollector& GetHistCollector() const { return fHistCollector; }
/**
* @}
*/
Double_t delta = pp[AliForwardUtil::ELossFitter::kDelta];
Double_t xi = pp[AliForwardUtil::ELossFitter::kXi];
Double_t sigma = pp[AliForwardUtil::ELossFitter::kSigma];
- Double_t sigma_n = pp[AliForwardUtil::ELossFitter::kSigmaN];
+ Double_t sigmaN = pp[AliForwardUtil::ELossFitter::kSigmaN];
- return constant * AliForwardUtil::LandauGaus(x, delta, xi, sigma, sigma_n);
+ return constant * AliForwardUtil::LandauGaus(x, delta, xi, sigma, sigmaN);
}
//
Double_t delta = pp[AliForwardUtil::ELossFitter::kDelta];
Double_t xi = pp[AliForwardUtil::ELossFitter::kXi];
Double_t sigma = pp[AliForwardUtil::ELossFitter::kSigma];
- Double_t sigma_n = pp[AliForwardUtil::ELossFitter::kSigmaN];
+ Double_t sigmaN = pp[AliForwardUtil::ELossFitter::kSigmaN];
Int_t n = Int_t(pp[AliForwardUtil::ELossFitter::kN]);
Double_t* a = &(pp[AliForwardUtil::ELossFitter::kA]);
- return constant * AliForwardUtil::NLandauGaus(x, delta, xi, sigma, sigma_n,
+ return constant * AliForwardUtil::NLandauGaus(x, delta, xi, sigma, sigmaN,
n, a);
}
//
Double_t delta = pp[AliForwardUtil::ELossFitter::kDelta];
Double_t xi = pp[AliForwardUtil::ELossFitter::kXi];
Double_t sigma = pp[AliForwardUtil::ELossFitter::kSigma];
- Double_t sigma_n = pp[AliForwardUtil::ELossFitter::kSigmaN];
+ Double_t sigmaN = pp[AliForwardUtil::ELossFitter::kSigmaN];
Int_t i = Int_t(pp[AliForwardUtil::ELossFitter::kN]);
- return constant * AliForwardUtil::ILandauGaus(x,delta,xi,sigma,sigma_n,i);
+ return constant * AliForwardUtil::ILandauGaus(x,delta,xi,sigma,sigmaN,i);
}
//____________________________________________________________________
Double_t
AliForwardUtil::LandauGaus(Double_t x, Double_t delta, Double_t xi,
- Double_t sigma, Double_t sigma_n)
+ Double_t sigma, Double_t sigmaN)
{
//
// Calculate the value of a Landau convolved with a Gaussian
// @f$ f@f$ evaluated at @f$ x@f$.
//
Double_t deltap = delta - xi * mpshift;
- Double_t sigma2 = sigma_n*sigma_n + sigma*sigma;
- Double_t sigma1 = sigma_n == 0 ? sigma : TMath::Sqrt(sigma2);
+ Double_t sigma2 = sigmaN*sigmaN + sigma*sigma;
+ Double_t sigma1 = sigmaN == 0 ? sigma : TMath::Sqrt(sigma2);
Double_t xlow = x - fgConvolutionNSigma * sigma1;
Double_t xhigh = x + fgConvolutionNSigma * sigma1;
Double_t step = (xhigh - xlow) / fgConvolutionSteps;
//____________________________________________________________________
Double_t
AliForwardUtil::ILandauGaus(Double_t x, Double_t delta, Double_t xi,
- Double_t sigma, Double_t sigma_n, Int_t i)
+ Double_t sigma, Double_t sigmaN, Int_t i)
{
//
// Evaluate
// Return:
// @f$ f_i @f$ evaluated
//
- Double_t delta_i = (i == 1 ? delta : i * (delta + xi * TMath::Log(i)));
- Double_t xi_i = i * xi;
- Double_t sigma_i = (i == 1 ? sigma : TMath::Sqrt(Double_t(i))*sigma);
- if (sigma_i < 1e-10) {
+ Double_t deltaI = (i == 1 ? delta : i * (delta + xi * TMath::Log(i)));
+ Double_t xiI = i * xi;
+ Double_t sigmaI = (i == 1 ? sigma : TMath::Sqrt(Double_t(i))*sigma);
+ if (sigmaI < 1e-10) {
// Fall back to landau
- return AliForwardUtil::Landau(x, delta_i, xi_i);
+ return AliForwardUtil::Landau(x, deltaI, xiI);
}
- return AliForwardUtil::LandauGaus(x, delta_i, xi_i, sigma_i, sigma_n);
+ return AliForwardUtil::LandauGaus(x, deltaI, xiI, sigmaI, sigmaN);
}
//____________________________________________________________________
AliForwardUtil::IdLandauGausdPar(Double_t x,
UShort_t par, Double_t dPar,
Double_t delta, Double_t xi,
- Double_t sigma, Double_t sigma_n,
+ Double_t sigma, Double_t sigmaN,
Int_t i)
{
//
if (dPar == 0) return 0;
Double_t dp = dPar;
Double_t d2 = dPar / 2;
- Double_t delta_i = i * (delta + xi * TMath::Log(i));
- Double_t xi_i = i * xi;
+ Double_t deltaI = i * (delta + xi * TMath::Log(i));
+ Double_t xiI = i * xi;
Double_t si = TMath::Sqrt(Double_t(i));
- Double_t sigma_i = si*sigma;
+ Double_t sigmaI = si*sigma;
Double_t y1 = 0;
Double_t y2 = 0;
Double_t y3 = 0;
Double_t y4 = 0;
switch (par) {
case 0:
- y1 = ILandauGaus(x, delta_i+i*dp, xi_i, sigma_i, sigma_n, i);
- y2 = ILandauGaus(x, delta_i+i*d2, xi_i, sigma_i, sigma_n, i);
- y3 = ILandauGaus(x, delta_i-i*d2, xi_i, sigma_i, sigma_n, i);
- y4 = ILandauGaus(x, delta_i-i*dp, xi_i, sigma_i, sigma_n, i);
+ y1 = ILandauGaus(x, deltaI+i*dp, xiI, sigmaI, sigmaN, i);
+ y2 = ILandauGaus(x, deltaI+i*d2, xiI, sigmaI, sigmaN, i);
+ y3 = ILandauGaus(x, deltaI-i*d2, xiI, sigmaI, sigmaN, i);
+ y4 = ILandauGaus(x, deltaI-i*dp, xiI, sigmaI, sigmaN, i);
break;
case 1:
- y1 = ILandauGaus(x, delta_i, xi_i+i*dp, sigma_i, sigma_n, i);
- y2 = ILandauGaus(x, delta_i, xi_i+i*d2, sigma_i, sigma_n, i);
- y3 = ILandauGaus(x, delta_i, xi_i-i*d2, sigma_i, sigma_n, i);
- y4 = ILandauGaus(x, delta_i, xi_i-i*dp, sigma_i, sigma_n, i);
+ y1 = ILandauGaus(x, deltaI, xiI+i*dp, sigmaI, sigmaN, i);
+ y2 = ILandauGaus(x, deltaI, xiI+i*d2, sigmaI, sigmaN, i);
+ y3 = ILandauGaus(x, deltaI, xiI-i*d2, sigmaI, sigmaN, i);
+ y4 = ILandauGaus(x, deltaI, xiI-i*dp, sigmaI, sigmaN, i);
break;
case 2:
- y1 = ILandauGaus(x, delta_i, xi_i, sigma_i+si*dp, sigma_n, i);
- y2 = ILandauGaus(x, delta_i, xi_i, sigma_i+si*d2, sigma_n, i);
- y3 = ILandauGaus(x, delta_i, xi_i, sigma_i-si*d2, sigma_n, i);
- y4 = ILandauGaus(x, delta_i, xi_i, sigma_i-si*dp, sigma_n, i);
+ y1 = ILandauGaus(x, deltaI, xiI, sigmaI+si*dp, sigmaN, i);
+ y2 = ILandauGaus(x, deltaI, xiI, sigmaI+si*d2, sigmaN, i);
+ y3 = ILandauGaus(x, deltaI, xiI, sigmaI-si*d2, sigmaN, i);
+ y4 = ILandauGaus(x, deltaI, xiI, sigmaI-si*dp, sigmaN, i);
break;
case 3:
- y1 = ILandauGaus(x, delta_i, xi_i, sigma_i, sigma_n+dp, i);
- y2 = ILandauGaus(x, delta_i, xi_i, sigma_i, sigma_n+d2, i);
- y3 = ILandauGaus(x, delta_i, xi_i, sigma_i, sigma_n-d2, i);
- y4 = ILandauGaus(x, delta_i, xi_i, sigma_i, sigma_n-dp, i);
+ y1 = ILandauGaus(x, deltaI, xiI, sigmaI, sigmaN+dp, i);
+ y2 = ILandauGaus(x, deltaI, xiI, sigmaI, sigmaN+d2, i);
+ y3 = ILandauGaus(x, deltaI, xiI, sigmaI, sigmaN-d2, i);
+ y4 = ILandauGaus(x, deltaI, xiI, sigmaI, sigmaN-dp, i);
break;
default:
return 0;
//____________________________________________________________________
Double_t
AliForwardUtil::NLandauGaus(Double_t x, Double_t delta, Double_t xi,
- Double_t sigma, Double_t sigma_n, Int_t n,
+ Double_t sigma, Double_t sigmaN, Int_t n,
Double_t* a)
{
//
// Return:
// @f$ f_N(x;\Delta,\xi,\sigma')@f$
//
- Double_t result = ILandauGaus(x, delta, xi, sigma, sigma_n, 1);
+ Double_t result = ILandauGaus(x, delta, xi, sigma, sigmaN, 1);
for (Int_t i = 2; i <= n; i++)
- result += a[i-2] * AliForwardUtil::ILandauGaus(x,delta,xi,sigma,sigma_n,i);
+ result += a[i-2] * AliForwardUtil::ILandauGaus(x,delta,xi,sigma,sigmaN,i);
return result;
}
namespace {
TF1*
AliForwardUtil::MakeNLandauGaus(Double_t c,
Double_t delta, Double_t xi,
- Double_t sigma, Double_t sigma_n, Int_t n,
+ Double_t sigma, Double_t sigmaN, Int_t n,
Double_t* a,
Double_t xmin, Double_t xmax)
{
landaun->SetParameter(AliForwardUtil::ELossFitter::kDelta, delta);
landaun->SetParameter(AliForwardUtil::ELossFitter::kXi, xi);
landaun->SetParameter(AliForwardUtil::ELossFitter::kSigma, sigma);
- landaun->SetParameter(AliForwardUtil::ELossFitter::kSigmaN, sigma_n);
+ landaun->SetParameter(AliForwardUtil::ELossFitter::kSigmaN, sigmaN);
landaun->FixParameter(AliForwardUtil::ELossFitter::kN, n);
// Set the range and name of the scale parameters
TF1*
AliForwardUtil::MakeILandauGaus(Double_t c,
Double_t delta, Double_t xi,
- Double_t sigma, Double_t sigma_n, Int_t i,
+ Double_t sigma, Double_t sigmaN, Int_t i,
Double_t xmin, Double_t xmax)
{
//
landaui->SetParameter(AliForwardUtil::ELossFitter::kDelta, delta);
landaui->SetParameter(AliForwardUtil::ELossFitter::kXi, xi);
landaui->SetParameter(AliForwardUtil::ELossFitter::kSigma, sigma);
- landaui->SetParameter(AliForwardUtil::ELossFitter::kSigmaN, sigma_n);
+ landaui->SetParameter(AliForwardUtil::ELossFitter::kSigmaN, sigmaN);
landaui->FixParameter(AliForwardUtil::ELossFitter::kN, i);
return landaui;
Int_t fNAccepted;
/** Number of events accepted */
Int_t fNAll;
+ /** Min vertex */
+ Double_t fVtxMin;
+ /** Max vertex */
+ Double_t fVtxMax;
+
//__________________________________________________________________
/**
vzMin < 0 ? 'm' : 'p', Int_t(TMath::Abs(vzMin)+.5),
vzMax < 0 ? 'm' : 'p', Int_t(TMath::Abs(vzMax)+.5),
rebin, trgName.Data());
- fTitle = title;
+ fTitle = title;
+ fVtxMin = vzMin;
+ fVtxMax = vzMax;
if (!Open(file, outName)) return kFALSE;
- if (!Process(vzMin,vzMax,mask)) return kFALSE;
+ if (!Process(mask)) return kFALSE;
if (!Finish(rebin, mask, energy,doHHD,doComp)) return kFALSE;
return kTRUE;
*
* @return true on success, false otherwise
*/
- Bool_t Process(Double_t vzMin, Double_t vzMax, Int_t mask)
+ Bool_t Process(Int_t mask)
{
fNTriggered = 0; // # of triggered ev.
fNWithVertex = 0; // # of ev. w/vertex
fNWithVertex++;
// Select vertex range (in centimeters)
- if (!fAOD->InRange(vzMin, vzMax)) continue;
+ if (!fAOD->InRange(fVtxMin, fVtxMax)) continue;
fNAccepted++;
// Add contribution from this event
// Info("DrawIt", "Setting maximum to %f", max);
stack->SetMinimum(ratios ? -0.1 : 0);
stack->SetMaximum(max);
- FixAxis(stack, 1/(1-yd)/1.5, "#frac{1}{N} #frac{dN_{ch}}{#eta}");
+ FixAxis(stack, 1/(1-yd)/1.5,
+ "#frac{1}{#it{N}} #frac{#it{dN}_{ch}}{#it{d#eta}}");
p1->Clear();
stack->DrawClone("nostack e1");
tit->Draw();
// Put a nice label in the plot
+ TString eS;
+ if (energy > 1000) eS = Form("%4.2fTeV", float(energy)/1000);
+ else eS = Form("%3dGeV", energy);
TLatex* tt = new TLatex(.93, .93,
- Form("#sqrt{s}=%dGeV, %s", energy,
+ Form("#sqrt{s}=%s, %s", eS.Data(),
AliAODForwardMult::GetTriggerString(mask)));
tt->SetNDC();
tt->SetTextFont(132);
tt->SetTextAlign(33);
tt->Draw();
- // Mark the plot as preliminary
- TLatex* pt = new TLatex(.93, .88, "Preliminary");
+ // Put number of accepted events on the plot
+ TLatex* et = new TLatex(.93, .83, Form("%d events", fNAccepted));
+ et->SetNDC();
+ et->SetTextFont(132);
+ et->SetTextAlign(33);
+ et->Draw();
+
+ // Put number of accepted events on the plot
+ TLatex* vt = new TLatex(.93, .88,
+ Form("v_{z}#in[%+5.1f,%+5.1f]cm", fVtxMin, fVtxMax));
+ vt->SetNDC();
+ vt->SetTextFont(132);
+ vt->SetTextAlign(33);
+ vt->Draw();
+
+ // Mark the plot as preliminary
+ TLatex* pt = new TLatex(.12, .93, "Preliminary");
pt->SetNDC();
pt->SetTextFont(22);
pt->SetTextSize(0.07);
pt->SetTextColor(kRed+1);
- pt->SetTextAlign(33);
+ pt->SetTextAlign(13);
pt->Draw();
c->cd();
* @ingroup pwg2_forward_scripts
*/
void MakeAOD(const char* esddir,
- Int_t nEvents=1000,
- Bool_t proof=false,
+ Int_t nEvents=-1,
+ Int_t proof=0,
Bool_t mc=false)
{
// --- Libraries to load -------------------------------------------
gROOT->Macro("$ALICE_ROOT/PWG2/FORWARD/analysis2/scripts/LoadLibs.C");
// --- Check for proof mode, and possibly upload pars --------------
- if (proof)
- gROOT->Macro("$ALICE_ROOT/PWG2/FORWARD/analysis2/scripts/LoadPars.C");
+ if (proof> 0) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWG2/FORWARD/analysis2/scripts/LoadPars.C");
+ LoadPars(proof);
+ }
// --- Our data chain ----------------------------------------------
gROOT->LoadMacro("$ALICE_ROOT/PWG2/FORWARD/analysis2/scripts/MakeESDChain.C");
- TChain* chain = MakeESDChain(esddir,mc);
+ TChain* chain = MakeESDChain(esddir,true);
// If 0 or less events is select, choose all
if (nEvents <= 0) nEvents = chain->GetEntries();
"Cascades "
"MuonTracks "
"TrdTracks "
- "CaloClusters "
"HLTGlobalTrigger");
mgr->SetInputEventHandler(esdHandler);
aodHandler->SetOutputFileName("AliAODs.root");
// --- Add tasks ---------------------------------------------------
- gROOT->LoadMacro("$ALICE_ROOT/PWG2/FORWARD/analysis2/AddTaskFMD.C");
+ // Physics selection
gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
- AddTaskFMD(mc);
AddTaskPhysicsSelection(mc, kTRUE, kTRUE);
+
+#if 0
+ // Centrality
+ gROOT->LoadMacro("$ALICE_ROOT/PWG2/FORWARD/analysis2/scripts/Compile.C");
+ // gDebug = 10;
+ Compile("$ALICE_ROOT/PWG2/FORWARD/analysis2/AddTaskCopyHeader.C","+");
+ // gDebug = 0;
+ AddTaskCopyHeader();
+#endif
+
+ // FMD
+ gROOT->LoadMacro("$ALICE_ROOT/PWG2/FORWARD/analysis2/AddTaskFMD.C");
+ AddTaskFMD(mc);
+
// --- Run the analysis --------------------------------------------
TStopwatch t;
*/
void
Pass1(const char* esddir=".",
- Int_t nEvents=1000,
- Bool_t proof=false,
+ Int_t nEvents=-1,
+ Int_t proof=0,
Bool_t mc=false)
{
- Printf(" MC: %s", mc ? "yes" : "no");
- Printf(" Proof mode %s", proof ? "yes" : "no");
+ Printf(" MC: %s", mc ? "yes" : "no");
+ Printf(" Proof mode %s", proof > 0 ? "yes" : "no");
gROOT->LoadMacro("$ALICE_ROOT/PWG2/FORWARD/analysis2/MakeAOD.C");
#!/bin/bash
ana=$ALICE_ROOT/PWG2/FORWARD/analysis2
-nev=10000
+nev=-1
noanal=0
nodraw=0
rebin=1
-t,--trigger TYPE Select trigger TYPE ($type)
-e,--energy CMS Center of mass energy ($cms)
-b,--batch Do batch processing ($batch)
- -P,--proof Run in PROOF(Lite) mode ($proof)
+ -P,--proof NWORKERS Run in PROOF(Lite) mode ($proof)
-M,--mc Run over MC data ($mc)
-S,--title STRING Set the title string ($tit)
-g,--gdb Run in GDB mode ($gdb)
INEL>0 As above + N_ch > 0 in -0.5<eta<+0.5
NSD Non-single diffractive ((VOA&VOC)|N_ch > 5 -1.9<eta<+1.9)
+If NWORKERS is 0, then the analysis will be run in local mode.
EOF
}
-2|--pass2) noanal=`toggle $noanal` ;;
-1|--pass1) nodraw=`toggle $nodraw` ;;
-b|--batch) batch=`toggle $batch` ;;
- -P|--proof) proof=`toggle $proof` ;;
+ -P|--proof) proof=$2 ; shift ;;
-M|--mc) mc=`toggle $mc` ;;
-g|--gdb) gdb=`toggle $gdb` ;;
-H|--hhd) hhd=`toggle $hhd` ;;
shift
done
-base=`printf dndeta_%07d $nev`
+if test $nev -lt 0 ; then
+ base=dndeta_xxxxxxx
+else
+ base=`printf dndeta_%07d $nev`
+fi
opts="-l -x"
opts1=""
redir=
if test $nodraw -lt 1 ; then
rm -f result.root
- if test "x$tit" = "x" ; then
- tit="$nev events, v_{z}#in[$vzmin,$vzmax], $type"
- fi
tit=`echo $tit | tr ' ' '@'`
echo "Running aliroot ${opts} ${opts1} ${ana}/Pass2.C\(\"AliAODs.root\",\"$type\",$cms,$vzmin,$vzmax,$rebin,$hhd,$comp\)"
aliroot ${opts} ${ana}/Pass2.C\(\"AliAODs.root\",\"$type\",$cms,$vzmin,$vzmax,$rebin,\"$tit\",$hhd,$comp\)
*
*/
void
-LoadPars()
+LoadPars(Int_t nWorkers=4)
{
- TProof::Open("workers=2");
+ TProof::Open(Form("workers=%d", nWorkers));
const char* pkgs[] = { "STEERBase", "ESD", "AOD", "ANALYSIS",
"ANALYSISalice", "PWG2forward2", 0};
const char** pkg = pkgs;
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff