Enable usage of compatibility band for PID (A. Rossi)

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