#include <AliLog.h>
#include <iostream>
#include "TH2F.h"
+#include <TBrowser.h>
#include "AliFMDAnaParameters.h"
ClassImp(AliFMDAnaCalibEnergyDistribution)
#if 0
fIsInit(kFALSE),
fNetaBins(0),
fEtaMax(0),
- fEtaMin(0){
+ fEtaMin(0)
+{
}
AliFatal("Set Eta bins before doing Init or anything else");
fArray.SetOwner();
+ fArray.SetName("etaBins");
fEmptyArray.SetOwner();
-
+ fEmptyArray.SetName("empty");
+ fRingArray.SetName("rings");
+
for(Int_t i = 0; i<fNetaBins; i++) {
TObjArray* etaArray = new TObjArray();
+ etaArray->SetName(Form("etabin_%03d", i+1));
fArray.AddAtAndExpand(etaArray,i);
for(Int_t det = 1; det<=3;det++) {
TObjArray* detArray = new TObjArray();
+ detArray->SetName(Form("FMD%d", det));
etaArray->AddAtAndExpand(detArray,det);
}
}
for(Int_t det = 1; det<=3;det++) {
TObjArray* detArray = new TObjArray();
+ detArray->SetName(Form("FMD%d", det));
fEmptyArray.AddAtAndExpand(detArray,det);
}
for(Int_t det = 1; det<=3;det++) {
TObjArray* detArray = new TObjArray();
+ detArray->SetName(Form("FMD%d", det));
fRingArray.AddAtAndExpand(detArray,det);
}
detArray->AddAtAndExpand(edist,ringNumber);
}
+//____________________________________________________________________
+void AliFMDAnaCalibEnergyDistribution::Browse(TBrowser* b)
+{
+ for(Int_t i = 0; i<fNetaBins; i++) {
+ TObjArray* etaArray = static_cast<TObjArray*>(fArray.At(i));
+ etaArray->SetName(Form("etabin_%03d", i+1));
+ for(Int_t det = 1; det<=3;det++) {
+ TObjArray* detArray = static_cast<TObjArray*>(etaArray->At(det));
+ detArray->SetName(Form("FMD%d", det));
+ }
+ }
+
+ for(Int_t det = 1; det<=3;det++) {
+ TObjArray* detArray = static_cast<TObjArray*>(fEmptyArray.At(det));
+ detArray->SetName(Form("FMD%d", det));
+ }
+
+ for(Int_t det = 1; det<=3;det++) {
+ TObjArray* detArray = static_cast<TObjArray*>(fRingArray.At(det));
+ detArray->SetName(Form("FMD%d", det));
+ }
+
+ b->Add(&fArray, "etabins");
+ b->Add(&fEmptyArray,"empty");
+ b->Add(&fRingArray, "rings");
+}
+
//____________________________________________________________________
//
// EOF
#include <TObject.h>
#include <TObjArray.h>
#include <TH1F.h>
+class TBrowser;
/**
* @ingroup FMD_ana
TH1F* GetEmptyEnergyDistribution(Int_t det, Char_t ring);
void SetRingEnergyDistribution(Int_t det, Char_t ring, TH1F* edist);
TH1F* GetRingEnergyDistribution(Int_t det, Char_t ring);
+ Bool_t IsFolder() const { return kTRUE; }
+ void Browse(TBrowser* b);
protected:
void Init();
TObjArray fArray;
-
+// Code to analyse dN/deta from the forward analysis
+// This can plot the results
+// Also works for MC data
+//
+// -- Author: Hans Hjersing Dalsgaard <canute@gmail.com>
#include "AliFMDDndeta.h"
#include "TFile.h"
#include "AliLog.h"
// INEL
- TGraphAsymmErrors* p7742_d1x1y1 = 0;
- double p7742_d1x1y1_xval[] = { -1.3, -1.1, -0.9, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3,
+ TGraphAsymmErrors* p7742D1x1y1 = 0;
+ double p7742D1x1y1xval[] = { -1.3, -1.1, -0.9, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3,
0.5, 0.7, 0.9, 1.1, 1.3 };
- double p7742_d1x1y1_xerrminus[] = { 0.09999999999999987, 0.09999999999999987, 0.09999999999999998, 0.10000000000000009, 0.09999999999999998, 0.10000000000000003, 0.1, 0.1, 0.09999999999999998,
+ double p7742D1x1y1xerrminus[] = { 0.09999999999999987, 0.09999999999999987, 0.09999999999999998, 0.10000000000000009, 0.09999999999999998, 0.10000000000000003, 0.1, 0.1, 0.09999999999999998,
0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.10000000000000009, 0.10000000000000009 };
- double p7742_d1x1y1_xerrplus[] = { 0.10000000000000009, 0.10000000000000009, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.1, 0.1, 0.10000000000000003,
+ double p7742D1x1y1xerrplus[] = { 0.10000000000000009, 0.10000000000000009, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.1, 0.1, 0.10000000000000003,
0.09999999999999998, 0.10000000000000009, 0.09999999999999998, 0.09999999999999987, 0.09999999999999987 };
- double p7742_d1x1y1_yval[] = { 3.28, 3.28, 3.22, 3.12, 3.06, 3.02, 2.98, 3.02, 3.02,
+ double p7742D1x1y1yval[] = { 3.28, 3.28, 3.22, 3.12, 3.06, 3.02, 2.98, 3.02, 3.02,
3.05, 3.15, 3.21, 3.26, 3.33 };
- double p7742_d1x1y1_yerrminus[] = { 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.05385164807134505, 0.05385164807134505, 0.05385164807134505, 0.05385164807134505,
+ double p7742D1x1y1yerrminus[] = { 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.05385164807134505, 0.05385164807134505, 0.05385164807134505, 0.05385164807134505,
0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.06324555320336758, 0.06324555320336758 };
- double p7742_d1x1y1_yerrplus[] = { 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.07280109889280519, 0.08246211251235322, 0.08246211251235322,
+ double p7742D1x1y1yerrplus[] = { 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.07280109889280519, 0.08246211251235322, 0.08246211251235322,
0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322, 0.08246211251235322 };
- int p7742_d1x1y1_numpoints = 14;
- p7742_d1x1y1 = new TGraphAsymmErrors(p7742_d1x1y1_numpoints, p7742_d1x1y1_xval, p7742_d1x1y1_yval, p7742_d1x1y1_xerrminus, p7742_d1x1y1_xerrplus, p7742_d1x1y1_yerrminus, p7742_d1x1y1_yerrplus);
- p7742_d1x1y1->SetName("/HepData/7742/d1x1y1");
- p7742_d1x1y1->SetTitle("/HepData/7742/d1x1y1");
- p7742_d1x1y1->SetMarkerStyle(21);
- p7742_d1x1y1->SetMarkerColor(kRed);
- // p7742_d1x1y1->Draw("Psame");
+ int p7742D1x1y1numpoints = 14;
+ p7742D1x1y1 = new TGraphAsymmErrors(p7742D1x1y1numpoints, p7742D1x1y1xval, p7742D1x1y1yval, p7742D1x1y1xerrminus, p7742D1x1y1xerrplus, p7742D1x1y1yerrminus, p7742D1x1y1yerrplus);
+ p7742D1x1y1->SetName("/HepData/7742/d1x1y1");
+ p7742D1x1y1->SetTitle("/HepData/7742/d1x1y1");
+ p7742D1x1y1->SetMarkerStyle(21);
+ p7742D1x1y1->SetMarkerColor(kRed);
+ // p7742D1x1y1->Draw("Psame");
//NSD
- TGraphAsymmErrors* p7742_d2x1y1 = 0;
- double p7742_d2x1y1_xval[] = { -1.3, -1.1, -0.9, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3,
+ TGraphAsymmErrors* p7742D2x1y1 = 0;
+ double p7742D2x1y1xval[] = { -1.3, -1.1, -0.9, -0.7, -0.5, -0.3, -0.1, 0.1, 0.3,
0.5, 0.7, 0.9, 1.1, 1.3 };
- double p7742_d2x1y1_xerrminus[] = { 0.09999999999999987, 0.09999999999999987, 0.09999999999999998, 0.10000000000000009, 0.09999999999999998, 0.10000000000000003, 0.1, 0.1, 0.09999999999999998,
+ double p7742D2x1y1xerrminus[] = { 0.09999999999999987, 0.09999999999999987, 0.09999999999999998, 0.10000000000000009, 0.09999999999999998, 0.10000000000000003, 0.1, 0.1, 0.09999999999999998,
0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.10000000000000009, 0.10000000000000009 };
- double p7742_d2x1y1_xerrplus[] = { 0.10000000000000009, 0.10000000000000009, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.1, 0.1, 0.10000000000000003,
+ double p7742D2x1y1xerrplus[] = { 0.10000000000000009, 0.10000000000000009, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.09999999999999998, 0.1, 0.1, 0.10000000000000003,
0.09999999999999998, 0.10000000000000009, 0.09999999999999998, 0.09999999999999987, 0.09999999999999987 };
- double p7742_d2x1y1_yval[] = { 3.9, 3.89, 3.81, 3.7, 3.64, 3.59, 3.53, 3.58, 3.59,
+ double p7742D2x1y1yval[] = { 3.9, 3.89, 3.81, 3.7, 3.64, 3.59, 3.53, 3.58, 3.59,
3.61, 3.74, 3.8, 3.87, 3.95 };
- double p7742_d2x1y1_yerrminus[] = { 0.13341664064126335, 0.13152946437965907, 0.13152946437965907, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644,
+ double p7742D2x1y1yerrminus[] = { 0.13341664064126335, 0.13152946437965907, 0.13152946437965907, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644,
0.1216552506059644, 0.1216552506059644, 0.13152946437965907, 0.13152946437965907, 0.13341664064126335 };
- double p7742_d2x1y1_yerrplus[] = { 0.13341664064126335, 0.13152946437965907, 0.13152946437965907, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644,
+ double p7742D2x1y1yerrplus[] = { 0.13341664064126335, 0.13152946437965907, 0.13152946437965907, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644, 0.1216552506059644,
0.1216552506059644, 0.1216552506059644, 0.13152946437965907, 0.13152946437965907, 0.13341664064126335 };
- int p7742_d2x1y1_numpoints = 14;
+ int p7742D2x1y1numpoints = 14;
- p7742_d2x1y1 = new TGraphAsymmErrors(p7742_d2x1y1_numpoints, p7742_d2x1y1_xval, p7742_d2x1y1_yval, p7742_d2x1y1_xerrminus, p7742_d2x1y1_xerrplus, p7742_d2x1y1_yerrminus, p7742_d2x1y1_yerrplus);
- p7742_d2x1y1->SetName("/HepData/7742/d2x1y1");
- p7742_d2x1y1->SetTitle("/HepData/7742/d2x1y1");
- p7742_d2x1y1->SetMarkerStyle(21);
- p7742_d2x1y1->SetMarkerColor(kRed);
- //p7742_d2x1y1.Draw("AP");
+ p7742D2x1y1 = new TGraphAsymmErrors(p7742D2x1y1numpoints, p7742D2x1y1xval, p7742D2x1y1yval, p7742D2x1y1xerrminus, p7742D2x1y1xerrplus, p7742D2x1y1yerrminus, p7742D2x1y1yerrplus);
+ p7742D2x1y1->SetName("/HepData/7742/d2x1y1");
+ p7742D2x1y1->SetTitle("/HepData/7742/d2x1y1");
+ p7742D2x1y1->SetMarkerStyle(21);
+ p7742D2x1y1->SetMarkerColor(kRed);
+ //p7742D2x1y1.Draw("AP");
// CMS published NSD data
- TGraphAsymmErrors* p7743_d8x1y1 = 0;
- double p7743_d8x1y1_xval[] = { -2.25, -1.75, -1.25, -0.75, -0.25, 0.25, 0.75, 1.25, 1.75,
+ TGraphAsymmErrors* p7743D8x1y1 = 0;
+ double p7743D8x1y1xval[] = { -2.25, -1.75, -1.25, -0.75, -0.25, 0.25, 0.75, 1.25, 1.75,
2.25 };
- double p7743_d8x1y1_xerrminus[] = { 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25 };
- double p7743_d8x1y1_xerrplus[] = { 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25 };
- double p7743_d8x1y1_yval[] = { 3.6, 3.73, 3.62, 3.54, 3.48, 3.48, 3.54, 3.62, 3.73, 3.6 };
- double p7743_d8x1y1_yerrminus[] = { 0.13, 0.14, 0.13, 0.13, 0.13, 0.13, 0.13, 0.13, 0.14,0.13 };
- double p7743_d8x1y1_yerrplus[] = { 0.13, 0.14, 0.13, 0.13, 0.13, 0.13, 0.13, 0.13, 0.14, 0.13 };
- int p7743_d8x1y1_numpoints = 10;
- p7743_d8x1y1 = new TGraphAsymmErrors(p7743_d8x1y1_numpoints, p7743_d8x1y1_xval, p7743_d8x1y1_yval, p7743_d8x1y1_xerrminus, p7743_d8x1y1_xerrplus, p7743_d8x1y1_yerrminus, p7743_d8x1y1_yerrplus);
+ double p7743D8x1y1xerrminus[] = { 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25 };
+ double p7743D8x1y1xerrplus[] = { 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25, 0.25 };
+ double p7743D8x1y1yval[] = { 3.6, 3.73, 3.62, 3.54, 3.48, 3.48, 3.54, 3.62, 3.73, 3.6 };
+ double p7743D8x1y1yerrminus[] = { 0.13, 0.14, 0.13, 0.13, 0.13, 0.13, 0.13, 0.13, 0.14,0.13 };
+ double p7743D8x1y1yerrplus[] = { 0.13, 0.14, 0.13, 0.13, 0.13, 0.13, 0.13, 0.13, 0.14, 0.13 };
+ int p7743D8x1y1numpoints = 10;
+ p7743D8x1y1 = new TGraphAsymmErrors(p7743D8x1y1numpoints, p7743D8x1y1xval, p7743D8x1y1yval, p7743D8x1y1xerrminus, p7743D8x1y1xerrplus, p7743D8x1y1yerrminus, p7743D8x1y1yerrplus);
- p7743_d8x1y1->SetMarkerStyle(20);
- p7743_d8x1y1->SetMarkerColor(kBlack);
+ p7743D8x1y1->SetMarkerStyle(20);
+ p7743D8x1y1->SetMarkerColor(kBlack);
//End CMS
if(what != kMultNSD) {
graphinel->Draw("PEsame");
graphinel2->Draw("PEsame");
- p7742_d1x1y1->Draw("PEsame");
+ p7742D1x1y1->Draw("PEsame");
}
else{
graph->Draw("PEsame");
graph2->Draw("PEsame");
- p7742_d2x1y1->Draw("PEsame");
- p7743_d8x1y1->Draw("PEsame");
+ p7742D2x1y1->Draw("PEsame");
+ p7743D8x1y1->Draw("PEsame");
}
//leg->AddEntry(hPythiaMB,"Pythia MB","l");
leg->AddEntry(hSPDcombi,"HHD SPD clusters","p");
if(what == kMult)
- leg->AddEntry(p7742_d1x1y1,"ALICE INEL published","p");
+ leg->AddEntry(p7742D1x1y1,"ALICE INEL published","p");
if(what == kMultNSD) {
- leg->AddEntry(p7742_d2x1y1,"ALICE NSD published","p");
- leg->AddEntry(p7743_d8x1y1, "CMS NSD published","p");
+ leg->AddEntry(p7742D2x1y1,"ALICE NSD published","p");
+ leg->AddEntry(p7743D8x1y1, "CMS NSD published","p");
}
}
leg->Draw();
//hTestdNdeta->DrawCopy("same");
//hSPDcombi->DrawCopy("same");
if(what == kMult)
- p7742_d1x1y1->Draw("PEsame");
+ p7742D1x1y1->Draw("PEsame");
if(what == kMultNSD) {
- p7742_d2x1y1->Draw("PEsame");
- p7743_d8x1y1->Draw("PEsame");
+ p7742D2x1y1->Draw("PEsame");
+ p7743D8x1y1->Draw("PEsame");
}
TLegend* leg2 = new TLegend(0.3,0.2,0.7,0.45,"");
//leg2->AddEntry(hPythiaMB,"Pythia MB","l");
//leg2->AddEntry(hSPDcombi,"HHD SPD clusters","p");
if(what == kMult)
- leg2->AddEntry(p7742_d1x1y1,"ALICE INEL published","p");
+ leg2->AddEntry(p7742D1x1y1,"ALICE INEL published","p");
if(what == kMultNSD) {
- leg2->AddEntry(p7742_d2x1y1,"ALICE NSD published","p");
- leg2->AddEntry(p7743_d8x1y1,"CMS NSD published","p");
+ leg2->AddEntry(p7742D2x1y1,"ALICE NSD published","p");
+ leg2->AddEntry(p7743D8x1y1,"CMS NSD published","p");
}
}
leg2->Draw();
-// -*- mode: C++ -*-
+// Code to analyse dN/deta from the forward analysis
+// This can plot the results
+// Also works for MC data
#ifndef ALIFMDDNDETA_H
#define ALIFMDDNDETA_H
#include "TObject.h"
-#include "TList.h"
+// #include "TList.h"
#include "TString.h"
+class TList;
class TH1F;
class TH3F;
class TProfile3D;
*
* @return
*/
- TList* GetMultList(Analysis what) {return fMultList[what];}
+ TList* GetMultList(Analysis what) const {return fMultList[what];}
private:
void GenerateHits(Analysis what);
void SetNames(Analysis what);
#endif
// Local Variables:
// mode: C++
-// End Variables;
+// End:
+/**
+ * @defgroup pwg2_forward_scripts Scripts used in the analysis
+ *
+ * @ingroup pwg2_forward
+ */
+/**
+ * @file
+ * @ingroup pwg2_forward_scripts
+ *
+ */
/**
* This is the macro to include the Forward multiplicity in a train.
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
AliAnalysisTask*
AddTaskFMD()
* The histogram can be used as input for other kinds of analysis too,
* like flow, event-plane, centrality, and so on.
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliAODForwardMult : public TObject
{
class TF1;
class TBrowser;
+/**
+ * @defgroup pwg2_forward_corr Corrections
+ *
+ * @ingroup pwg2_forward
+ */
/**
* Object holding the Energy loss fit 'correction'
*
/**
* POD structure to hold data from fits
*
+ * @ingroup pwg2_forward_corr
*/
struct ELossFit : public TObject
{
/**
* Constructor with full parameter set
*
- * @param d Detector number
- * @param r Ring identifier
* @param quality Quality flag
* @param n @f$ N@f$ - Number of fitted peaks
* @param chi2 @f$ \chi^2 @f$
* @param nu @f$ \nu @f$ - number degrees of freedom
- * @param c @f$ C2f$ - scale constant
+ * @param c @f$ C@f$ - scale constant
* @param ec @f$ \delta C@f$ - error on @f$ C@f$
- * @param delta @f$ \Delta2f$ - scale constant
+ * @param delta @f$ \Delta@f$ - Most probable value
* @param edelta @f$ \delta\Delta@f$ - error on @f$\Delta@f$
- * @param xi @f$ \xi2f$ - scale constant
+ * @param xi @f$ \xi@f$ - width
* @param exi @f$ \delta\xi@f$ - error on @f$\xi@f$
- * @param sigma @f$ \sigma@f$ - scale constant
+ * @param sigma @f$ \sigma@f$ - Width of Gaussian
* @param esigma @f$ \delta\sigma@f$ - error on @f$\sigma@f$
- * @param sigman @f$ \sigma_n@f$ - scale constant
+ * @param sigman @f$ \sigma_n@f$ - Noise width
* @param esigman @f$ \delta\sigma_n@f$ - error on @f$\sigma_n@f$
* @param a Array of @f$ N-1@f$ weights @f$ a_i@f$ for
* @f$ i=2,\ldots@f$
+ * @param ea Array of @f$ N-1@f$ error on the weights @f$ a_i@f$ for
+ * @f$ i=2,\ldots@f$
*/
ELossFit(Int_t quality,UShort_t n,
Double_t chi2, UShort_t nu,
/**
* Set the fit parameters from a function
*
- * @param d Detector
- * @param r Ring
- * @param eta Eta (bin number, 1->nBins)
- * @param f ELoss fit result - note, the object will take ownership
+ * @param d Detector
+ * @param r Ring
+ * @param etaBin Eta (bin number, 1->nBins)
+ * @param f ELoss fit result - note, the object will take ownership
*/
Bool_t SetFit(UShort_t d, Char_t r, Int_t etaBin, ELossFit* f);
/**
*
* @param d Detector number
* @param r Ring identifier
+ * @param eta Eta value
* @param quality Quality flag
* @param n @f$ N@f$ - Number of fitted peaks
* @param chi2 @f$ \chi^2 @f$
* @param nu @f$ \nu @f$ - number degrees of freedom
- * @param c @f$ C2f$ - scale constant
+ * @param c @f$ C@f$ - scale constant
* @param ec @f$ \delta C@f$ - error on @f$ C@f$
- * @param delta @f$ \Delta2f$ - scale constant
+ * @param delta @f$ \Delta@f$ - most probable value
* @param edelta @f$ \delta\Delta@f$ - error on @f$\Delta@f$
- * @param xi @f$ \xi2f$ - scale constant
+ * @param xi @f$ \xi@f$ - Landau width
* @param exi @f$ \delta\xi@f$ - error on @f$\xi@f$
- * @param sigma @f$ \sigma@f$ - scale constant
+ * @param sigma @f$ \sigma@f$ - Gaussian width
* @param esigma @f$ \delta\sigma@f$ - error on @f$\sigma@f$
- * @param sigman @f$ \sigma_n@f$ - scale constant
+ * @param sigman @f$ \sigma_n@f$ - Noise width
* @param esigman @f$ \delta\sigma_n@f$ - error on @f$\sigma_n@f$
* @param a Array of @f$ N-1@f$ weights @f$ a_i@f$ for
* @f$ i=2,\ldots@f$
+ * @param ea Array of @f$ N-1@f$ errors on weights @f$ a_i@f$ for
+ * @f$ i=2,\ldots@f$
*/
Bool_t SetFit(UShort_t d, Char_t r, Double_t eta,
Int_t quality,UShort_t n,
/**
* Set the eta axis to use
*
- * @param axis Eta axis
+ * @param nBins Number of bins
+ * @param min Minimum @f$ \eta@f$
+ * @param max maximum @f$ \eta@f$
*/
void SetEtaAxis(Int_t nBins, Double_t min, Double_t max);
/**
/**
* Set the vertex axis to use
*
- * @param axis Vertex axis
+ * @param nBins Number of bins
+ * @param min Minimum
+ * @param max Maximum
*/
void SetVertexAxis(Int_t nBins, Double_t min, Double_t max);
/* @} */
*
* @param vertex The interaction points @f$z@f$-coordinate
*
- * @return Vertex bin in @f$[1,N_{\box{vertex}}]@f$ or negative if
+ * @return Vertex bin in @f$[1,N_{\mbox{vertex}}]@f$ or negative if
* out of range
*/
Int_t FindVertexBin(Double_t vertex) const;
/**
* Set the vertex axis to use
*
- * @param axis Vertex axis
- */
+ * @param nBins Number of bins
+ * @param min Minimum
+ * @param max Maximum
+ */
void SetVertexAxis(Int_t nBins, Double_t min, Double_t max);
/**
* Set the eta axis to use
/**
* Set the eta axis to use
*
- * @param axis Eta axis
+ * @param nBins Number of bins
+ * @param min Minimum
+ * @param max Maximum
*/
void SetEtaAxis(Int_t nBins, Double_t min, Double_t max);
/* @} */
*
* @param vertex The interaction points @f$z@f$-coordinate
*
- * @return Vertex bin in @f$[1,N_{\box{vertex}}]@f$ or negative if
+ * @return Vertex bin in @f$[1,N_{\mbox{vertex}}]@f$ or negative if
* out of range
*/
Int_t FindVertexBin(Double_t vertex) const;
/**
* Set the vertex axis to use
*
- * @param axis Vertex axis
+ * @param nBins Number of bins
+ * @param min Minimum
+ * @param max Maximum
*/
void SetVertexAxis(Int_t nBins, Double_t min, Double_t max);
/* @} */
*
* @param vertex The interaction points @f$z@f$-coordinate
*
- * @return Vertex bin in @f$[1,N_{\box{vertex}}]@f$ or negative if
+ * @return Vertex bin in @f$[1,N_{\mbox{vertex}}]@f$ or negative if
* out of range
*/
Int_t FindVertexBin(Double_t vertex) const;
* - AliFMDAnaCalibEventSelectionEfficiency
* - AliFMDAnaCalibSharingEfficiency
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDCorrections : public TNamed
{
* - AliFMDDoubleHitCorrection
* - AliFMDDeadCorrection
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDDensityCalculator : public TNamed
{
*
* @return Reference to this object
*/
- AliFMDDensityCalculator& operator=(const AliFMDDensityCalculator&);
+ AliFMDDensityCalculator& operator=(const AliFMDDensityCalculator& o);
/**
* Do the calculations
*
AliFMDEnergyFitter::Init(const TAxis& eAxis)
{
if (fEtaAxis.GetNbins() == 0 ||
- fEtaAxis.GetXmin() == fEtaAxis.GetXmax())
+ TMath::Abs(fEtaAxis.GetXmax() - fEtaAxis.GetXmin()) < 1e-7)
SetEtaAxis(eAxis);
TIter next(&fRingHistos);
RingHistos* o = 0;
//____________________________________________________________________
void
-AliFMDEnergyFitter::Fit(TList* dir)
+AliFMDEnergyFitter::Fit(const TList* dir)
{
if (!fDoFits) return;
-#ifndef ALIROOT_PWG2_FORWARD_ALIFMDENERGYFITTER_H
-#define ALIROOT_PWG2_FORWARD_ALIFMDENERGYFITTER_H
+#ifndef ALIFMDENERGYFITTER_H
+#define ALIFMDENERGYFITTER_H
#include <TNamed.h>
#include <TH1D.h>
#include <TAxis.h>
* - None
*
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDEnergyFitter : public TNamed
{
* @param x Number of energy loss bins
*/
void SetNEbins(Int_t x) { fNEbins = x; }
+ /**
+ * Set the maximum relative error
+ *
+ * @param e Maximum relative error
+ */
void SetMaxRelativeParameterError(Double_t e=0.2) { fMaxRelParError = e; }
+ /**
+ * Set the maximum @f$ \chi^2/\nu@f$
+ *
+ * @param c Maximum @f$ \chi^2/\nu@f$
+ */
void SetMaxChi2PerNDF(Double_t c=10) { fMaxChi2PerNDF = c; }
+ /**
+ * Set the least weight
+ *
+ * @param c Least weight
+ */
void SetMinWeight(Double_t c=1e-7) { fMinWeight = c; }
/**
* Set wheter to use increasing bin sizes
*
* @param dir Where the histograms are
*/
- void Fit(TList* dir);
+ void Fit(const TList* dir);
+ /**
+ * Generate the corrections object
+ *
+ * @param dir List to analyse
+ */
void MakeCorrectionsObject(TList* dir);
/**
Double_t relErrorCut,
Double_t chi2nuCut) const;
/**
- * Fit a signal histogram. First, the bin @f% b_{min}@f$ with
+ * Fit a signal histogram. First, the bin @f$ b_{min}@f$ with
* maximum bin content in the range @f$ [E_{min},\infty]@f$ is
* found. Then the fit range is set to the bin range
* @f$ [b_{min}-\Delta b,b_{min}+2\Delta b]@f$, and a 1
/**
* Make E/E_mip histogram
*
- * @param ieta Eta bin
- * @param eMin Least signal
- * @param eMax Largest signal
+ * @param ieta Eta bin
+ * @param eMin Least signal
+ * @param eMax Largest signal
+ * @param deMax Maximum energy loss
+ * @param nDeBins Number energy loss bins
+ * @param incr Whether to make bins of increasing size
*/
void Make(Int_t ieta, Double_t eMin, Double_t eMax,
Double_t deMax=12, Int_t nDeBins=300, Bool_t incr=true);
class TTree;
-/**
- * @mainpage ALICE PWG2 Forward Multiplcity Analysis
- */
-/**
- * @defgroup pwg2_forward_analysis PWG2 Forward analysis
- *
- * Code to do the multiplicity analysis in the forward psuedo-rapidity
- * regions
- *
- */
/**
* Histogram and fit the energy loss distributions for the FMD
*
* @par Corrections used
* - None
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward_tasks
*
*/
class AliFMDEnergyFitterTask : public AliAnalysisTaskSE
* @par Corrections used:
* - None
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDEventInspector : public TNamed
{
* Process the event
*
* @param event Input event
- * @param first True on first event
* @param triggers On return, the triggers fired
* @param lowFlux On return, true if the event is considered a low-flux
* event (according to the setting of fLowFluxCut)
* @par HistCollector used:
* - AliFMDAnaCalibBackgroundCorrection
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDHistCollector : public TNamed
{
* @par Corrections used:
* - None
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDMCDensityCalculator : public AliFMDDensityCalculator
{
*
* @return Reference to this object
*/
- AliFMDMCDensityCalculator& operator=(const AliFMDMCDensityCalculator&);
+ AliFMDMCDensityCalculator& operator=(const AliFMDMCDensityCalculator& o);
/**
* Do the calculations
*
* hit strips for each vertex bin (if enabled - see Init method)
*
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliFMDSharingFilter : public TNamed
{
#include <TString.h>
class TFile;
+/**
+ * Manager (singleton) of corrections
+ *
+ * @ingroup pwg2_forward_corr
+ */
class AliForwardCorrectionManager : public TObject
{
public:
* @param collisionSystem Collision system
* @param cmsNN Center of mass energy per nuclean pair [GeV]
* @param field Magnetic field setting [kG]
+ * @param mc Monte-carlo switch
* @param what What to read in.
* @param force Force (re-)reading of specified things
*
*
* @par Corrections used
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward_tasks
*
*/
class AliForwardMCCorrectionsTask : public AliAnalysisTaskSE
* @mainpage ALICE PWG2 Forward Multiplcity Analysis
*/
/**
- * @defgroup pwg2_forward_analysis PWG2 Forward analysis
+ * @defgroup pwg2_forward PWG2 Forward analysis
*
* Code to do the multiplicity analysis in the forward psuedo-rapidity
* regions
*
*/
+/**
+ * @defgroup pwg2_forward_tasks Tasks
+ *
+ * Code to do the multiplicity analysis in the forward psuedo-rapidity
+ * regions
+ *
+ * @ingroup pwg2_forward
+ */
/**
* Calculate the multiplicity in the forward regions event-by-event
*
*
* @par Corrections used
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward_tasks
*
*/
class AliForwardMultiplicityTask : public AliAnalysisTaskSE
/**
* Utilities used in the forward multiplcity analysis
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
class AliForwardUtil : public TObject
{
//==================================================================
/**
* @{
- * @nane Collision/run parameters
+ * @name Collision/run parameters
*/
/**
* Defined collision types
/**
* Get a string representation of the center of mass energy per nuclean
*
- * @param sys Collision system
- * @param sNN Center of mass energy per nucleon
+ * @param cms Center of mass energy per nucleon
*
* @return String representation of the center of mass energy per nuclean
*/
* f_i(x;\Delta,\xi,\sigma') = f(x;\Delta_i,\xi_i,\sigma_i')
* @f]
* corresponding to @f$ i@f$ particles i.e., with the substitutions
- * @f[
- * \Delta \rightarrow \Delta_i = i(\Delta + \xi\log(i))\\
- * \xi \rightarrow \xi_i = i \xi\\
- * \sigma \rightarrow \sigma_i = \sqrt{i}\sigma\\
- * \sigma'^2 \rightarrow \sigma_i'^2 = \sigma_n^2 + \sigma_i^2
- * @f]
+ * @f{eqnarray*}{
+ * \Delta \rightarrow \Delta_i &=& i(\Delta + \xi\log(i))\\
+ * \xi \rightarrow \xi_i &=& i \xi\\
+ * \sigma \rightarrow \sigma_i &=& \sqrt{i}\sigma\\
+ * \sigma'^2 \rightarrow \sigma_i'^2 &=& \sigma_n^2 + \sigma_i^2
+ * @f}
*
* @param x Where to evaluate
* @param delta @f$ \Delta@f$
* @param xi @f$ \xi@f$
* @param sigma @f$ \sigma@f$
* @param sigma_n @f$ \sigma_n@f$
- * @param i @f$ i@f$
+ * @param i @f$ i @f$
*
- * @return @f$ f_i@f$ evaluated
+ * @return @f$ f_i @f$ evaluated
*/
static Double_t ILandauGaus(Double_t x, Double_t delta, Double_t xi,
Double_t sigma, Double_t sigma_n, Int_t i);
*
* @param x Where to evaluate
* @param ipar Parameter number
- * @param dp @f$ \esilon\delta p_i@f$ for some value of @f$\epsilon@f$
+ * @param dp @f$ \epsilon\delta p_i@f$ for some value of @f$\epsilon@f$
* @param delta @f$ \Delta@f$
* @param xi @f$ \xi@f$
* @param sigma @f$ \sigma@f$
/**
* Structure to hold histograms
*
- * @ingroup pwg2_forward_analysis
+ * @ingroup pwg2_forward
*/
struct Histos : public TObject
{
+/**
+ * @file
+ *
+ * @ingroup pwg2_forward_scripts
+ */
#include <TH1D.h>
#include <TH2D.h>
#include <TCanvas.h>
*
* See also the script Pass2.C
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
struct DrawRes
{
+/**
+ * @file
+ *
+ * @ingroup pwg2_forward_scripts
+ */
#include <TGraphAsymmErrors.h>
#include <TMultiGraph.h>
#include <TStyle.h>
//____________________________________________________________________
/**
- * @defgroup pwg2_forward_analysis_otherdata External data
+ * @defgroup pwg2_forward_otherdata External data
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
//____________________________________________________________________
/**
* Values used
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
enum {
/** Color used for UA5 data */
* @param name Name of graph
* @param title Title of graph
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
void
SetGraphAttributes(TGraph* g, Int_t marker, Int_t color,
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* UA5Nsd(Bool_t mirrored=false)
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* UA5Inel(Bool_t mirrored=false)
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralInel900()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralInelGt900()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralInelGt2360()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralInelGt7000()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralNsd900()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralInel2360()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* AliceCentralNsd2360()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* CMSNsd900()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* CMSNsd2360()
{
*
* @return graph of data
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TGraphAsymmErrors* CMSNsd7000()
{
*
* @return A multi graph with the selected data.
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
TMultiGraph*
GetData(Int_t energy, Int_t type)
* @param energy Energy in GeV
* @param type Trigger type bit mask
*
- * @ingroup pwg2_forward_analysis_otherdata
+ * @ingroup pwg2_forward_otherdata
*/
void
OtherData(Int_t energy=900, Int_t type=0x1)
+/**
+ * @file
+ *
+ * @ingroup pwg2_forward_scripts
+ */
/**
* Run first pass of the analysis - that is read in ESD and produce AOD
*
* function is then called
*
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
void
Pass1(const char* esddir=".",
+/**
+ * @file
+ *
+ * @ingroup pwg2_forward_scripts
+ */
/**
* Read in AOD and generate @f$ dN/d\eta@f$ for the selected
* trigger classes and vertex ranges
* @param hhd Whether to do HHD comparison
* @param comp Whether to do comparisons
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
void
Pass2(const char* file="AliAODs.root",
-/**
- * Flags for the analysis
- *
- * @ingroup pwg2_forward_analysis_scripts
+/**
+ * @file
+ *
+ * @ingroup pwg2_forward_scripts
*/
/**
* Run a pass on ESD data to produce the energ loss fits
*
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
void RunELossFitter(const char* esddir,
Int_t nEvents=1000,
+/**
+ * @file
+ *
+ * @ingroup pwg2_forward_scripts
+ */
/**
* Flags for the analysis
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
enum {
kMC = 0x01, // MC input
* function is then called
*
*
- * @ingroup pwg2_forward_analysis_scripts
+ * @ingroup pwg2_forward_scripts
*/
void RunManager(const char* esddir,
Int_t nEvents=1000,
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff