[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();

 private:

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

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

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

  void InitDstoKKpi2010pp();
  void InitDstoKKpi2011PbPb07half();

  void InitLctopKpi2010pp();

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


  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="");
1cad7456	26
	27	virtual ~AliHFSystErr();
	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
	83
5541b811	84	// Function to initialize the variables/histograms
5541b811	85	void Init(Int_t decay);
1cad7456	86
414bc6a5	87	void InitD0toKpi2010PbPb010CentScan();
	88	void InitD0toKpi2010PbPb1020CentScan();
	89	void InitD0toKpi2010PbPb2040CentScan();
	90	void InitD0toKpi2010PbPb4060CentScan();
	91	void InitD0toKpi2010PbPb6080CentScan();
	92
93da8165	93	void InitD0toKpi2011PbPb3050InPlane();
	94	void InitD0toKpi2011PbPb3050OutOfPlane();
	95
414bc6a5	96	void InitDplustoKpipi2010PbPb010CentScan();
	97	void InitDplustoKpipi2010PbPb1020CentScan();
	98	void InitDplustoKpipi2010PbPb2040CentScan();
	99	void InitDplustoKpipi2010PbPb4060CentScan();
	100	void InitDplustoKpipi2010PbPb6080CentScan();
	101
	102	void InitDstartoD0pi2010PbPb010CentScan();
	103	void InitDstartoD0pi2010PbPb1020CentScan();
	104	void InitDstartoD0pi2010PbPb2040CentScan();
	105	void InitDstartoD0pi2010PbPb4060CentScan();
	106	void InitDstartoD0pi2010PbPb6080CentScan();
9ca30701	107
3db225bf	108	void InitD0toKpi2011PbPb010CentScan();
	109	void InitD0toKpi2011PbPb1020CentScan();
	110	void InitD0toKpi2011PbPb2030CentScan();
	111	void InitD0toKpi2011PbPb3040CentScan();
	112	void InitD0toKpi2011PbPb4050CentScan();
	113	void InitD0toKpi2010PbPb5080CentScan();
	114
	115	void InitDplustoKpipi2011PbPb010CentScan();
	116	void InitDplustoKpipi2011PbPb1020CentScan();
	117	void InitDplustoKpipi2011PbPb2030CentScan();
	118	void InitDplustoKpipi2011PbPb3040CentScan();
	119	void InitDplustoKpipi2011PbPb4050CentScan();
	120	void InitDplustoKpipi2010PbPb5080CentScan();
	121
	122	void InitDstartoD0pi2011PbPb010CentScan();
	123	void InitDstartoD0pi2011PbPb1020CentScan();
	124	void InitDstartoD0pi2011PbPb2030CentScan();
	125	void InitDstartoD0pi2011PbPb3040CentScan();
	126	void InitDstartoD0pi2011PbPb4050CentScan();
	127	void InitDstartoD0pi2010PbPb5080CentScan();
	128
44dd56b2	129	void InitD0toKpi2013pPb0100RapScan0804();
	130	void InitD0toKpi2013pPb0100RapScan0401();
	131	void InitD0toKpi2013pPb0100RapScan0101();
	132	void InitD0toKpi2013pPb0100RapScan0104();
	133	void InitD0toKpi2013pPb0100RapScan0408();
	134
	135	void InitDplustoKpipi2013pPb0100RapScan0804();
	136	void InitDplustoKpipi2013pPb0100RapScan0401();
	137	void InitDplustoKpipi2013pPb0100RapScan0101();
	138	void InitDplustoKpipi2013pPb0100RapScan0104();
	139	void InitDplustoKpipi2013pPb0100RapScan0408();
	140
	141	void InitDstartoD0pi2013pPb0100RapScan0804();
	142	void InitDstartoD0pi2013pPb0100RapScan0401();
	143	void InitDstartoD0pi2013pPb0100RapScan0101();
	144	void InitDstartoD0pi2013pPb0100RapScan0104();
	145	void InitDstartoD0pi2013pPb0100RapScan0408();
	146
1cad7456	147	private:
	148
	149	AliHFSystErr(const AliHFSystErr& source);
	150	AliHFSystErr& operator=(const AliHFSystErr& source);
	151
5541b811	152	void InitD0toKpi2010pp();
9ca30701	153	void InitD0toKpi2010ppLowEn();
9a8b5080	154	void InitD0toKpi2011PbPb07half();
9ca30701	155	void InitD0toKpi2010PbPb020();
5541b811	156	void InitD0toKpi2010PbPb4080();
9ca30701	157
	158	void InitDplustoKpipi2010pp();
	159	void InitDplustoKpipi2010ppLowEn();
	160	void InitDplustoKpipi2011PbPb07half();
	161	void InitDplustoKpipi2010PbPb020();
5541b811	162	void InitDplustoKpipi2010PbPb4080();
9ca30701	163
	164	void InitDstartoD0pi2010pp();
	165	void InitDstartoD0pi2010ppLowEn();
	166	void InitDstartoD0pi2011PbPb07half();
	167	void InitDstartoD0pi2010PbPb020();
	168	void InitDstartoD0pi2010PbPb2040();
5541b811	169	void InitDstartoD0pi2010PbPb4080();
1cad7456	170
9ca30701	171	void InitDstoKKpi2010pp();
9ca30701	172	void InitDstoKKpi2011PbPb07half();
414bc6a5	173
9ca30701	174	void InitLctopKpi2010pp();
a8c3295d	175
86164e35	176	void InitD0toKpi2013pPb0100();
	177	void InitDplustoKpipi2013pPb0100();
	178	void InitDstartoD0pi2013pPb0100();
	179	void InitDstoKKpi2013pPb0100();
	180
1cad7456	181
f968ef30	182	TH1F* ReflectHisto(TH1F *hin) const;
f968ef30	183
1cad7456	184	TH1F *fNorm; // normalization
	185	TH1F *fRawYield; // raw yield
	186	TH1F *fTrackingEff; // tracking efficiency
	187	TH1F *fBR; // branching ratio
	188	TH1F *fCutsEff; // cuts efficiency
	189	TH1F *fPIDEff; // PID efficiency
	190	TH1F *fMCPtShape; // MC dNdpt
	191	TH1F *fPartAntipart; // particle=antiparticle
	192
5541b811	193	Int_t fRunNumber; // Run Number (year)
5541b811	194	Int_t fCollisionType; // Collision type: pp=0, PbPb=1
aebba8df	195	TString fCentralityClass; // Centrality class
5541b811	196	// MB:0100, 0-10:010, 0-20:020 ...40-80:4080...
44dd56b2	197	TString fRapidityRange; // Rapidity range fot y measurements
44dd56b2	198
a8c3295d	199	Bool_t fIsLowEnergy; // flag for the low energy (2.76TeV) run
cede55f5	200	Bool_t fIsCentScan; // flag fot the PbPb centrality scan
44dd56b2	201	Bool_t fIsRapidityScan; // flag for the pPb vs y measurement
	202
	203	ClassDef(AliHFSystErr,5); // class for systematic errors of charm hadrons
1cad7456	204	};
	205
	206	#endif
	207