[u/mrichter/AliRoot.git] / PWGHF / vertexingHF / AliHFSystErr.h

#ifndef ALIHFSYSTERR_H
#define ALIHFSYSTERR_H
/* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
 * See cxx source for full Copyright notice                               */

/* $Id$ */ 

//***********************************************************
// Class AliRDHFSystErr
// to handle systematic errors for charm hadrons
// Author: A.Dainese, andrea.dainese@pd.infn.it
//***********************************************************

#include <TNamed.h>
#include <TString.h>
#include <TH1F.h>
#include "AliLog.h"
#include "TGraphAsymmErrors.h"


class AliHFSystErr : public TNamed 
{
 public:

  AliHFSystErr(const Char_t* name="HFSystErr", const Char_t* title="");
    
  virtual ~AliHFSystErr();
  
  void DrawErrors(TGraphAsymmErrors *grErrFeeddown=0) const; 

  Double_t GetNormErr() const {return (fNorm ? fNorm->GetBinContent(0) : 0.);}
  Double_t GetBRErr() const {return (fBR ? fBR->GetBinContent(0) : 0.);}
  Double_t GetCutsEffErr(Double_t pt) const;
  Double_t GetMCPtShapeErr(Double_t pt) const;
  Double_t GetSeleEffErr(Double_t pt) const;
  Double_t GetPartAntipartErr(Double_t pt) const;
  Double_t GetPIDEffErr(Double_t pt) const;
  Double_t GetRawYieldErr(Double_t pt) const;
  Double_t GetTrackingEffErr(Double_t pt) const;
  Double_t GetTotalSystErr(Double_t pt,Double_t feeddownErr=0) const;

  // Setting  the run number
  //  set the two last numbers of the year (is 10 for 2010)
  void SetRunNumber(Int_t number) { 
    fRunNumber = number; 
    AliInfo(Form(" Settings for run year 20%2d",fRunNumber));
  }
  Int_t GetRunNumber() const { return fRunNumber; }
  // Setting the collision type
  //  0 is pp, 1 is PbPb, 2 is pPb
  void SetCollisionType(Int_t type) { 
    fCollisionType = type; 
    if (fCollisionType==0) { AliInfo(" Settings for p-p collisions"); }
    else if(fCollisionType==1) { AliInfo(" Settings for Pb-Pb collisions"); }
    else if(fCollisionType==2) { AliInfo(" Settings for p-Pb collisions"); }
  }
  Int_t GetCollisionType() const { return fCollisionType; }
  // Setting for the centrality class
  //  0100 for MB, 020 (4080) for 0-20 (40-80) CC and so on
  void SetCentrality(TString centrality) { 
    fCentralityClass = centrality; 
    AliInfo(Form(" Settings for centrality class %s",fCentralityClass.Data()));
  }
  void SetIsLowEnergy(Bool_t flag) { 
    fIsLowEnergy = flag; 
    AliInfo(" Settings for the low energy run");
  }
  void SetIsPbPb2010EnergyScan(Bool_t flag) {
    fIsCentScan = flag;
    AliInfo(" Settings for the PbPb 2010 energy scan");
  }

  // Settings of rapidity ranges for pPb 0-100% CC
  void SetRapidity(TString rapidity) {
    fRapidityRange = rapidity;
    AliInfo(Form(" Settings for rapidity interval %s",fRapidityRange.Data()));
  }
  void SetIspPb2011RapidityScan(Bool_t flag){
    fIsRapidityScan = flag; 
    AliInfo("Settings for the pPb vs y measurement");
  }

  // Function to initialize the variables/histograms
  void Init(Int_t decay);

  void InitD0toKpi2010PbPb010CentScan();
  void InitD0toKpi2010PbPb1020CentScan();
  void InitD0toKpi2010PbPb2040CentScan();
  void InitD0toKpi2010PbPb4060CentScan();
  void InitD0toKpi2010PbPb6080CentScan();

  void InitD0toKpi2011PbPb3050InPlane();
  void InitD0toKpi2011PbPb3050OutOfPlane();

  void InitDplustoKpipi2010PbPb010CentScan();
  void InitDplustoKpipi2010PbPb1020CentScan();
  void InitDplustoKpipi2010PbPb2040CentScan();
  void InitDplustoKpipi2010PbPb4060CentScan();
  void InitDplustoKpipi2010PbPb6080CentScan();

  void InitDstartoD0pi2010PbPb010CentScan();
  void InitDstartoD0pi2010PbPb1020CentScan();
  void InitDstartoD0pi2010PbPb2040CentScan();
  void InitDstartoD0pi2010PbPb4060CentScan();
  void InitDstartoD0pi2010PbPb6080CentScan();

  void InitD0toKpi2011PbPb010CentScan();
  void InitD0toKpi2011PbPb1020CentScan();
  void InitD0toKpi2011PbPb2030CentScan();
  void InitD0toKpi2011PbPb3040CentScan();
  void InitD0toKpi2011PbPb4050CentScan();
  void InitD0toKpi2010PbPb5080CentScan();

  void InitDplustoKpipi2011PbPb010CentScan();
  void InitDplustoKpipi2011PbPb1020CentScan();
  void InitDplustoKpipi2011PbPb2030CentScan();
  void InitDplustoKpipi2011PbPb3040CentScan();
  void InitDplustoKpipi2011PbPb4050CentScan();
  void InitDplustoKpipi2010PbPb5080CentScan();

  void InitDstartoD0pi2011PbPb010CentScan();
  void InitDstartoD0pi2011PbPb1020CentScan();
  void InitDstartoD0pi2011PbPb2030CentScan();
  void InitDstartoD0pi2011PbPb3040CentScan();
  void InitDstartoD0pi2011PbPb4050CentScan();
  void InitDstartoD0pi2010PbPb5080CentScan();

  void InitD0toKpi2013pPb0100RapScan0804();
  void InitD0toKpi2013pPb0100RapScan0401();
  void InitD0toKpi2013pPb0100RapScan0101();
  void InitD0toKpi2013pPb0100RapScan0104();
  void InitD0toKpi2013pPb0100RapScan0408();

  void InitDplustoKpipi2013pPb0100RapScan0804();
  void InitDplustoKpipi2013pPb0100RapScan0401();
  void InitDplustoKpipi2013pPb0100RapScan0101();
  void InitDplustoKpipi2013pPb0100RapScan0104();
  void InitDplustoKpipi2013pPb0100RapScan0408();

  void InitDstartoD0pi2013pPb0100RapScan0804();
  void InitDstartoD0pi2013pPb0100RapScan0401();
  void InitDstartoD0pi2013pPb0100RapScan0101();
  void InitDstartoD0pi2013pPb0100RapScan0104();
  void InitDstartoD0pi2013pPb0100RapScan0408();
    
    
  void InitD0toKpi2013pPb020V0A();
  void InitD0toKpi2013pPb2040V0A();
  void InitD0toKpi2013pPb4060V0A();
  void InitD0toKpi2013pPb60100V0A();
    
  void InitD0toKpi2013pPb020ZNA();
  void InitD0toKpi2013pPb2040ZNA();
  void InitD0toKpi2013pPb4060ZNA();
  void InitD0toKpi2013pPb60100ZNA();
    
  void InitDstartoD0pi2013pPb020V0A();
  void InitDstartoD0pi2013pPb2040V0A();
  void InitDstartoD0pi2013pPb4060V0A();
  void InitDstartoD0pi2013pPb60100V0A();
    
  void InitDstartoD0pi2013pPb020ZNA();
  void InitDstartoD0pi2013pPb2040ZNA();
  void InitDstartoD0pi2013pPb4060ZNA();
  void InitDstartoD0pi2013pPb60100ZNA();

    
 private:

  AliHFSystErr(const AliHFSystErr& source);
  AliHFSystErr& operator=(const AliHFSystErr& source); 
 
  void InitD0toKpi2010pp();
  void InitD0toKpi2010ppLowEn();
  void InitD0toKpi2011PbPb07half();
  void InitD0toKpi2010PbPb020();
  void InitD0toKpi2010PbPb4080();
  void InitD0toKpi2011PbPb3050(); 
  void InitD0toKpi2011PbPb010();

  void InitDplustoKpipi2010pp();
  void InitDplustoKpipi2010ppLowEn();
  void InitDplustoKpipi2011PbPb07half();
  void InitDplustoKpipi2010PbPb020();
  void InitDplustoKpipi2010PbPb4080();
  void InitDplustoKpipi2011PbPb3050();
  void InitDplustoKpipi2011PbPb010();

  void InitDstartoD0pi2010pp();
  void InitDstartoD0pi2010ppLowEn();
  void InitDstartoD0pi2011PbPb07half();
  void InitDstartoD0pi2010PbPb020();
  void InitDstartoD0pi2010PbPb2040();
  void InitDstartoD0pi2010PbPb4080();
  void InitDstartoD0pi2011PbPb3050();
  void InitDstartoD0pi2011PbPb010();

  void InitDstoKKpi2010pp();
  void InitDstoKKpi2011PbPb07half();
  void InitDstoKKpi2011PbPb010();
  void InitDstoKKpi2011PbPb2050();

  void InitLctopKpi2010pp();

  void InitD0toKpi2013pPb0100();
  void InitDplustoKpipi2013pPb0100();
  void InitDstartoD0pi2013pPb0100();
  void InitDstoKKpi2013pPb0100();
  void InitLctopK0S2010pp();


  TH1F* ReflectHisto(TH1F *hin) const;

  TH1F *fNorm;            // normalization
  TH1F *fRawYield;        // raw yield 
  TH1F *fTrackingEff;     // tracking efficiency
  TH1F *fBR;              // branching ratio
  TH1F *fCutsEff;         // cuts efficiency
  TH1F *fPIDEff;          // PID efficiency
  TH1F *fMCPtShape;       // MC dNdpt
  TH1F *fPartAntipart;    // particle=antiparticle

  Int_t fRunNumber;        // Run Number (year)
  Int_t fCollisionType;    // Collision type: pp=0, PbPb=1
  TString fCentralityClass;  // Centrality class
                           // MB:0100, 0-10:010, 0-20:020 ...40-80:4080...
  TString fRapidityRange;  // Rapidity range fot y measurements 

  Bool_t fIsLowEnergy;     // flag for the low energy (2.76TeV) run
  Bool_t fIsCentScan;      // flag fot the PbPb centrality scan
  Bool_t fIsRapidityScan;  // flag for the pPb vs y measurement
 
  ClassDef(AliHFSystErr,5);  // class for systematic errors of charm hadrons
};

#endif
Commit	Line	Data
1cad7456	1	#ifndef ALIHFSYSTERR_H
	2	#define ALIHFSYSTERR_H
	3	/* Copyright(c) 1998-2010, ALICE Experiment at CERN, All rights reserved. *
	4	* See cxx source for full Copyright notice */
	5
27de2dfb	6	/* $Id$ */
27de2dfb	7
1cad7456	8	//***********************************************************
	9	// Class AliRDHFSystErr
	10	// to handle systematic errors for charm hadrons
	11	// Author: A.Dainese, andrea.dainese@pd.infn.it
	12	//***********************************************************
	13
	14	#include <TNamed.h>
aebba8df	15	#include <TString.h>
1cad7456	16	#include <TH1F.h>
5541b811	17	#include "AliLog.h"
8998180c	18	#include "TGraphAsymmErrors.h"
1cad7456	19
	20
	21	class AliHFSystErr : public TNamed
	22	{
	23	public:
	24
	25	AliHFSystErr(const Char_t* name="HFSystErr", const Char_t* title="");
fa90243b	26
1cad7456	27	virtual ~AliHFSystErr();
1cad7456	28
8998180c	29	void DrawErrors(TGraphAsymmErrors *grErrFeeddown=0) const;
1cad7456	30
	31	Double_t GetNormErr() const {return (fNorm ? fNorm->GetBinContent(0) : 0.);}
	32	Double_t GetBRErr() const {return (fBR ? fBR->GetBinContent(0) : 0.);}
	33	Double_t GetCutsEffErr(Double_t pt) const;
	34	Double_t GetMCPtShapeErr(Double_t pt) const;
	35	Double_t GetSeleEffErr(Double_t pt) const;
	36	Double_t GetPartAntipartErr(Double_t pt) const;
	37	Double_t GetPIDEffErr(Double_t pt) const;
	38	Double_t GetRawYieldErr(Double_t pt) const;
	39	Double_t GetTrackingEffErr(Double_t pt) const;
	40	Double_t GetTotalSystErr(Double_t pt,Double_t feeddownErr=0) const;
	41
5541b811	42	// Setting the run number
	43	// set the two last numbers of the year (is 10 for 2010)
	44	void SetRunNumber(Int_t number) {
	45	fRunNumber = number;
	46	AliInfo(Form(" Settings for run year 20%2d",fRunNumber));
	47	}
bd332272	48	Int_t GetRunNumber() const { return fRunNumber; }
5541b811	49	// Setting the collision type
86164e35	50	// 0 is pp, 1 is PbPb, 2 is pPb
5541b811	51	void SetCollisionType(Int_t type) {
	52	fCollisionType = type;
	53	if (fCollisionType==0) { AliInfo(" Settings for p-p collisions"); }
	54	else if(fCollisionType==1) { AliInfo(" Settings for Pb-Pb collisions"); }
86164e35	55	else if(fCollisionType==2) { AliInfo(" Settings for p-Pb collisions"); }
5541b811	56	}
bd332272	57	Int_t GetCollisionType() const { return fCollisionType; }
5541b811	58	// Setting for the centrality class
5541b811	59	// 0100 for MB, 020 (4080) for 0-20 (40-80) CC and so on
aebba8df	60	void SetCentrality(TString centrality) {
5541b811	61	fCentralityClass = centrality;
aebba8df	62	AliInfo(Form(" Settings for centrality class %s",fCentralityClass.Data()));
5541b811	63	}
a8c3295d	64	void SetIsLowEnergy(Bool_t flag) {
	65	fIsLowEnergy = flag;
	66	AliInfo(" Settings for the low energy run");
	67	}
cede55f5	68	void SetIsPbPb2010EnergyScan(Bool_t flag) {
	69	fIsCentScan = flag;
	70	AliInfo(" Settings for the PbPb 2010 energy scan");
	71	}
5541b811	72
ec87196b	73	// Settings of rapidity ranges for pPb 0-100% CC
	74	void SetRapidity(TString rapidity) {
	75	fRapidityRange = rapidity;
	76	AliInfo(Form(" Settings for rapidity interval %s",fRapidityRange.Data()));
	77	}
44dd56b2	78	void SetIspPb2011RapidityScan(Bool_t flag){
	79	fIsRapidityScan = flag;
	80	AliInfo("Settings for the pPb vs y measurement");
	81	}
	82
5541b811	83	// Function to initialize the variables/histograms
5541b811	84	void Init(Int_t decay);
1cad7456	85
414bc6a5	86	void InitD0toKpi2010PbPb010CentScan();
	87	void InitD0toKpi2010PbPb1020CentScan();
	88	void InitD0toKpi2010PbPb2040CentScan();
	89	void InitD0toKpi2010PbPb4060CentScan();
	90	void InitD0toKpi2010PbPb6080CentScan();
	91
93da8165	92	void InitD0toKpi2011PbPb3050InPlane();
	93	void InitD0toKpi2011PbPb3050OutOfPlane();
	94
414bc6a5	95	void InitDplustoKpipi2010PbPb010CentScan();
	96	void InitDplustoKpipi2010PbPb1020CentScan();
	97	void InitDplustoKpipi2010PbPb2040CentScan();
	98	void InitDplustoKpipi2010PbPb4060CentScan();
	99	void InitDplustoKpipi2010PbPb6080CentScan();
	100
	101	void InitDstartoD0pi2010PbPb010CentScan();
	102	void InitDstartoD0pi2010PbPb1020CentScan();
	103	void InitDstartoD0pi2010PbPb2040CentScan();
	104	void InitDstartoD0pi2010PbPb4060CentScan();
	105	void InitDstartoD0pi2010PbPb6080CentScan();
9ca30701	106
3db225bf	107	void InitD0toKpi2011PbPb010CentScan();
	108	void InitD0toKpi2011PbPb1020CentScan();
	109	void InitD0toKpi2011PbPb2030CentScan();
	110	void InitD0toKpi2011PbPb3040CentScan();
	111	void InitD0toKpi2011PbPb4050CentScan();
	112	void InitD0toKpi2010PbPb5080CentScan();
	113
	114	void InitDplustoKpipi2011PbPb010CentScan();
	115	void InitDplustoKpipi2011PbPb1020CentScan();
	116	void InitDplustoKpipi2011PbPb2030CentScan();
	117	void InitDplustoKpipi2011PbPb3040CentScan();
	118	void InitDplustoKpipi2011PbPb4050CentScan();
	119	void InitDplustoKpipi2010PbPb5080CentScan();
	120
	121	void InitDstartoD0pi2011PbPb010CentScan();
	122	void InitDstartoD0pi2011PbPb1020CentScan();
	123	void InitDstartoD0pi2011PbPb2030CentScan();
	124	void InitDstartoD0pi2011PbPb3040CentScan();
	125	void InitDstartoD0pi2011PbPb4050CentScan();
	126	void InitDstartoD0pi2010PbPb5080CentScan();
	127
44dd56b2	128	void InitD0toKpi2013pPb0100RapScan0804();
	129	void InitD0toKpi2013pPb0100RapScan0401();
	130	void InitD0toKpi2013pPb0100RapScan0101();
	131	void InitD0toKpi2013pPb0100RapScan0104();
	132	void InitD0toKpi2013pPb0100RapScan0408();
	133
	134	void InitDplustoKpipi2013pPb0100RapScan0804();
	135	void InitDplustoKpipi2013pPb0100RapScan0401();
	136	void InitDplustoKpipi2013pPb0100RapScan0101();
	137	void InitDplustoKpipi2013pPb0100RapScan0104();
	138	void InitDplustoKpipi2013pPb0100RapScan0408();
	139
	140	void InitDstartoD0pi2013pPb0100RapScan0804();
	141	void InitDstartoD0pi2013pPb0100RapScan0401();
	142	void InitDstartoD0pi2013pPb0100RapScan0101();
	143	void InitDstartoD0pi2013pPb0100RapScan0104();
	144	void InitDstartoD0pi2013pPb0100RapScan0408();
fa90243b	145
	146
	147	void InitD0toKpi2013pPb020V0A();
	148	void InitD0toKpi2013pPb2040V0A();
	149	void InitD0toKpi2013pPb4060V0A();
	150	void InitD0toKpi2013pPb60100V0A();
	151
	152	void InitD0toKpi2013pPb020ZNA();
	153	void InitD0toKpi2013pPb2040ZNA();
	154	void InitD0toKpi2013pPb4060ZNA();
	155	void InitD0toKpi2013pPb60100ZNA();
	156
	157	void InitDstartoD0pi2013pPb020V0A();
	158	void InitDstartoD0pi2013pPb2040V0A();
	159	void InitDstartoD0pi2013pPb4060V0A();
	160	void InitDstartoD0pi2013pPb60100V0A();
	161
	162	void InitDstartoD0pi2013pPb020ZNA();
	163	void InitDstartoD0pi2013pPb2040ZNA();
	164	void InitDstartoD0pi2013pPb4060ZNA();
	165	void InitDstartoD0pi2013pPb60100ZNA();
	166
	167
44dd56b2	168
1cad7456	169	private:
	170
	171	AliHFSystErr(const AliHFSystErr& source);
	172	AliHFSystErr& operator=(const AliHFSystErr& source);
	173
5541b811	174	void InitD0toKpi2010pp();
9ca30701	175	void InitD0toKpi2010ppLowEn();
9a8b5080	176	void InitD0toKpi2011PbPb07half();
9ca30701	177	void InitD0toKpi2010PbPb020();
5541b811	178	void InitD0toKpi2010PbPb4080();
830baf70	179	void InitD0toKpi2011PbPb3050();
c8617efe	180	void InitD0toKpi2011PbPb010();
9ca30701	181
	182	void InitDplustoKpipi2010pp();
	183	void InitDplustoKpipi2010ppLowEn();
	184	void InitDplustoKpipi2011PbPb07half();
	185	void InitDplustoKpipi2010PbPb020();
5541b811	186	void InitDplustoKpipi2010PbPb4080();
830baf70	187	void InitDplustoKpipi2011PbPb3050();
c8617efe	188	void InitDplustoKpipi2011PbPb010();
9ca30701	189
	190	void InitDstartoD0pi2010pp();
	191	void InitDstartoD0pi2010ppLowEn();
	192	void InitDstartoD0pi2011PbPb07half();
	193	void InitDstartoD0pi2010PbPb020();
	194	void InitDstartoD0pi2010PbPb2040();
5541b811	195	void InitDstartoD0pi2010PbPb4080();
830baf70	196	void InitDstartoD0pi2011PbPb3050();
c8617efe	197	void InitDstartoD0pi2011PbPb010();
1cad7456	198
9ca30701	199	void InitDstoKKpi2010pp();
9ca30701	200	void InitDstoKKpi2011PbPb07half();
1f7128ee	201	void InitDstoKKpi2011PbPb010();
1f7128ee	202	void InitDstoKKpi2011PbPb2050();
414bc6a5	203
9ca30701	204	void InitLctopKpi2010pp();
a8c3295d	205
86164e35	206	void InitD0toKpi2013pPb0100();
	207	void InitDplustoKpipi2013pPb0100();
	208	void InitDstartoD0pi2013pPb0100();
	209	void InitDstoKKpi2013pPb0100();
53c91ed7	210	void InitLctopK0S2010pp();
86164e35	211
1cad7456	212
f968ef30	213	TH1F* ReflectHisto(TH1F *hin) const;
f968ef30	214
1cad7456	215	TH1F *fNorm; // normalization
	216	TH1F *fRawYield; // raw yield
	217	TH1F *fTrackingEff; // tracking efficiency
	218	TH1F *fBR; // branching ratio
	219	TH1F *fCutsEff; // cuts efficiency
	220	TH1F *fPIDEff; // PID efficiency
	221	TH1F *fMCPtShape; // MC dNdpt
	222	TH1F *fPartAntipart; // particle=antiparticle
	223
5541b811	224	Int_t fRunNumber; // Run Number (year)
5541b811	225	Int_t fCollisionType; // Collision type: pp=0, PbPb=1
aebba8df	226	TString fCentralityClass; // Centrality class
5541b811	227	// MB:0100, 0-10:010, 0-20:020 ...40-80:4080...
44dd56b2	228	TString fRapidityRange; // Rapidity range fot y measurements
44dd56b2	229
a8c3295d	230	Bool_t fIsLowEnergy; // flag for the low energy (2.76TeV) run
cede55f5	231	Bool_t fIsCentScan; // flag fot the PbPb centrality scan
fa90243b	232	Bool_t fIsRapidityScan; // flag for the pPb vs y measurement
44dd56b2	233
44dd56b2	234	ClassDef(AliHFSystErr,5); // class for systematic errors of charm hadrons
1cad7456	235	};
	236
	237	#endif
	238