From e047b3485ee042ec00216587e55d81c9c2a92424 Mon Sep 17 00:00:00 2001 From: dainese Date: Mon, 20 Sep 2010 10:36:39 +0000 Subject: [PATCH] Update of task for D0 analysis (AndreaR) --- PWG3/vertexingHF/AddD2HTrain.C | 8 +- .../AliAnalysisTaskSECharmFraction.cxx | 4523 ++++++++++++++--- .../AliAnalysisTaskSECharmFraction.h | 109 +- PWG3/vertexingHF/RunAnalysisAODVertexingHF.C | 9 +- 4 files changed, 3915 insertions(+), 734 deletions(-) diff --git a/PWG3/vertexingHF/AddD2HTrain.C b/PWG3/vertexingHF/AddD2HTrain.C index 14421963fb8..aa4f2ace98e 100644 --- a/PWG3/vertexingHF/AddD2HTrain.C +++ b/PWG3/vertexingHF/AddD2HTrain.C @@ -80,10 +80,12 @@ Int_t AddD2HTrain(Bool_t readMC=kTRUE, } if(addPromptD0) { - taskName="AddTaskCharmFraction.C"; taskName.Prepend(loadMacroPath.Data()); + taskName="AddTaskSECharmFraction.C"; + taskName.Prepend(loadMacroPath.Data()); gROOT->LoadMacro(taskName.Data()); - Int_t switchMC[5]={1,1,1,1,1}; - AliAnalysisTaskSECharmFraction *cFractTask = AddTaskCharmFraction("d0D0.root",switchMC,readMC); + Int_t switchMC[5]={0,0,0,0,0}; + AliAnalysisTaskSECharmFraction *cFractTask = AddTaskSECharmFraction("standard",switchMC,readMC); + // arguments: filename,switchMC,readmc,usepid,likesign,cutfilename,containerprefix ntasks++; } diff --git a/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.cxx b/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.cxx index d90b6c9788b..2b3a24c1dc6 100644 --- a/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.cxx +++ b/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.cxx @@ -28,26 +28,31 @@ #include #include #include - -#include "AliAnalysisManager.h" -#include "AliAODHandler.h" #include "AliAODEvent.h" #include "AliAODRecoDecayHF2Prong.h" #include "AliAODRecoDecayHF.h" #include "AliAODRecoDecay.h" +#include "AliAnalysisDataSlot.h" +#include "AliAnalysisDataContainer.h" #include "AliAODTrack.h" +#include "AliAODHandler.h" +#include "AliESDtrack.h" #include "AliAODVertex.h" +#include "AliESDVertex.h" +#include "AliVertexerTracks.h" #include "AliAODMCParticle.h" +#include "AliAODPid.h" +#include "AliTPCPIDResponse.h" #include "AliAODMCHeader.h" #include "AliAnalysisVertexingHF.h" #include "AliAnalysisTaskSECharmFraction.h" - +#include "AliRDHFCutsD0toKpi.h" +#include "AliAODInputHandler.h" +#include "AliAnalysisManager.h" class TCanvas; class TTree; class TChain; -class AliAODInputHandler; -class AliAnalysisManager; class AliAnalysisTaskSE; @@ -56,12 +61,18 @@ ClassImp(AliAnalysisTaskSECharmFraction) //________________________________________________________________________ AliAnalysisTaskSECharmFraction::AliAnalysisTaskSECharmFraction() : AliAnalysisTaskSE(), - fVHFloose(0), - fVHFtight(0), + fCutsLoose(0), + fCutsTight(0), fReadMC(kFALSE), + fLikeSign(kFALSE), + fusePID(kTRUE), fmD0PDG(), - fnbins(), + fnbins(1), fptbins(0), + fNtrMaxforVtx(-1), + fptAll(), + fptAllSq(), + fptMax(), fAcceptanceCuts(), fsignalInvMassCut(), flargeInvMassCut(), @@ -72,6 +83,7 @@ ClassImp(AliAnalysisTaskSECharmFraction) fSignalType(0), fSignalTypeLsCuts(0), fSignalTypeTghCuts(0), + flistMCproperties(0), flistNoCutsSignal(0), flistNoCutsBack(0), flistNoCutsFromB(0), @@ -94,22 +106,29 @@ ClassImp(AliAnalysisTaskSECharmFraction) //________________________________________________________________________ AliAnalysisTaskSECharmFraction::AliAnalysisTaskSECharmFraction(const char *name) : AliAnalysisTaskSE(name), - fVHFloose(0), - fVHFtight(0), + fCutsLoose(0x0), + fCutsTight(0x0), fReadMC(kFALSE), + fLikeSign(kFALSE), + fusePID(kTRUE), fmD0PDG(), - fnbins(), + fnbins(1), fptbins(0), + fNtrMaxforVtx(-1), + fptAll(), + fptAllSq(), + fptMax(), fAcceptanceCuts(), - fsignalInvMassCut(), - flargeInvMassCut(), - fsidebandInvMassCut(), - fsidebandInvMassWindow(), - fUseMC(kTRUE), + fsignalInvMassCut(-1.), + flargeInvMassCut(-1.), + fsidebandInvMassCut(-1.), + fsidebandInvMassWindow(-1.), + fUseMC(kFALSE), fNentries(0), fSignalType(0), fSignalTypeLsCuts(0), fSignalTypeTghCuts(0), + flistMCproperties(0), flistNoCutsSignal(0), flistNoCutsBack(0), flistNoCutsFromB(0), @@ -134,46 +153,48 @@ ClassImp(AliAnalysisTaskSECharmFraction) // Output slot #0 writes into a TH1 container //Standard pt bin - fnbins=4; - fptbins=new Double_t[fnbins+1]; - fptbins[0]=0.; - fptbins[1]=1.; - fptbins[2]=3.; - fptbins[3]=5.; - fptbins[4]=1000.; - //fAcceptanceCuts=new Double_t[3]; - SetAcceptanceCut(); - SetStandardMassSelection(); + fnbins=SetStandardCuts(fptbins);// THIS TO SET NBINS AND BINNING + DefineOutput(1, TH1F::Class()); DefineOutput(2, TH1F::Class()); DefineOutput(3, TH1F::Class()); DefineOutput(4, TH1F::Class()); - for(Int_t j=5;j<20;j++){ + for(Int_t j=5;j<21;j++){ DefineOutput(j, TList::Class()); } + // Output slot for the Cut Objects + DefineOutput(21,AliRDHFCutsD0toKpi::Class()); //My private output + DefineOutput(22,AliRDHFCutsD0toKpi::Class()); //My private output } -AliAnalysisTaskSECharmFraction::AliAnalysisTaskSECharmFraction(const char *name,Int_t nptbins,Double_t *ptbins) +AliAnalysisTaskSECharmFraction::AliAnalysisTaskSECharmFraction(const char *name,AliRDHFCutsD0toKpi *cutsA,AliRDHFCutsD0toKpi *cutsB) : AliAnalysisTaskSE(name), - fVHFloose(0), - fVHFtight(0), + fCutsLoose(0), + fCutsTight(0), fReadMC(kFALSE), + fLikeSign(kFALSE), + fusePID(kTRUE), fmD0PDG(), - fnbins(), + fnbins(1), fptbins(0), + fNtrMaxforVtx(-1), + fptAll(), + fptAllSq(), + fptMax(), fAcceptanceCuts(), - fsignalInvMassCut(), - flargeInvMassCut(), - fsidebandInvMassCut(), - fsidebandInvMassWindow(), - fUseMC(kTRUE), + fsignalInvMassCut(-1.), + flargeInvMassCut(-1.), + fsidebandInvMassCut(-1.), + fsidebandInvMassWindow(-1.), + fUseMC(kFALSE), fNentries(0), fSignalType(0), fSignalTypeLsCuts(0), fSignalTypeTghCuts(0), + flistMCproperties(0), flistNoCutsSignal(0), flistNoCutsBack(0), flistNoCutsFromB(0), @@ -191,24 +212,39 @@ AliAnalysisTaskSECharmFraction::AliAnalysisTaskSECharmFraction(const char *name, flistTghCutsOther(0) { // Constructor - // ptbins must be of dimension nptbins +1 + if(fCutsTight)delete fCutsTight;fCutsTight=NULL; + if(fCutsLoose)delete fCutsLoose;fCutsLoose=NULL; + + //Check consistency between sets of cuts: + if(cutsA->GetNPtBins()!=cutsB->GetNPtBins()){ + printf("Different number of pt bins between the two sets of cuts: SWITCH TO STANDARD CUTS \n"); + fnbins=SetStandardCuts(fptbins); + } + else{ + fCutsTight=new AliRDHFCutsD0toKpi(*cutsA); + fCutsLoose=new AliRDHFCutsD0toKpi(*cutsB); + for(Int_t j=0;jGetNPtBins();j++){ + if(TMath::Abs(cutsA->GetPtBinLimits()[j]-cutsB->GetPtBinLimits()[j])>1.e-7){ + printf("Different pt bin limits in the two set of cuts: use the first as reference \n"); + fCutsLoose->SetPtBins(cutsA->GetNPtBins(),cutsA->GetPtBinLimits()); + break; + } + } + SetPtBins(fCutsTight->GetNPtBins(),fCutsTight->GetPtBinLimits()); + } - SetNPtBins(nptbins,ptbins); - SetStandardMassSelection(); - // fAcceptanceCuts=new Double_t[3]; - SetAcceptanceCut(); - // Define input and output slots here - // Output slot #0 writes into a TH1 container DefineOutput(1, TH1F::Class()); DefineOutput(2, TH1F::Class()); DefineOutput(3, TH1F::Class()); DefineOutput(4, TH1F::Class()); - for(Int_t j=5;j<20;j++){ + for(Int_t j=5;j<21;j++){ DefineOutput(j, TList::Class()); } - + // Output slot for the Cut Objects + DefineOutput(21,AliRDHFCutsD0toKpi::Class()); //My private output + DefineOutput(22,AliRDHFCutsD0toKpi::Class()); //My private output } @@ -216,13 +252,13 @@ AliAnalysisTaskSECharmFraction::AliAnalysisTaskSECharmFraction(const char *name, AliAnalysisTaskSECharmFraction::~AliAnalysisTaskSECharmFraction() { //Destructor - if (fVHFtight) { - delete fVHFtight; - fVHFtight = 0; + if (fCutsTight) { + delete fCutsTight; + fCutsTight = 0; } - if (fVHFloose) { - delete fVHFloose; - fVHFloose = 0; + if (fCutsLoose) { + delete fCutsLoose; + fCutsLoose = 0; } if(fptbins){ delete fptbins; @@ -248,6 +284,10 @@ AliAnalysisTaskSECharmFraction::~AliAnalysisTaskSECharmFraction() delete fSignalTypeTghCuts; fSignalTypeTghCuts = 0; } + if(flistMCproperties){ + delete flistMCproperties; + flistMCproperties=0; + } if(flistNoCutsSignal){ delete flistNoCutsSignal; flistNoCutsSignal=0; @@ -323,24 +363,27 @@ void AliAnalysisTaskSECharmFraction::Init() if(fDebug > 1) printf("AnalysisTaskSED0Mass::Init() \n"); fmD0PDG = TDatabasePDG::Instance()->GetParticle(421)->Mass(); - gROOT->LoadMacro("$ALICE_ROOT/PWG3/vertexingHF/ConfigVertexingHF.C"); + // gROOT->LoadMacro("$ALICE_ROOT/PWG3/vertexingHF/ConfigVertexingHF.C"); + // gROOT->LoadMacro("$ALICE_ROOT/PWG3/vertexingHF/D0fromBSetCuts.C"); + // 2 sets of dedicated cuts: fCutsTight is assumed as the standard cut object - // 2 sets of dedidcated cuts -- defined in UserExec - // the config file and the way the cuts are set is for further development - // (to be interfaced with AliAnalsysTaskSETuneCuts) - - fVHFtight = (AliAnalysisVertexingHF*)gROOT->ProcessLine("ConfigVertexingHF()"); - fVHFloose = (AliAnalysisVertexingHF*)gROOT->ProcessLine("ConfigVertexingHF()"); - if(!fptbins){ - //SET STANDARD PT BINNING - fnbins=4; - fptbins=new Double_t[fnbins+1]; - fptbins[0]=0.; - fptbins[1]=1.; - fptbins[2]=3.; - fptbins[3]=5.; - fptbins[4]=1000.; + // SetAcceptanceCut(); + if(fNtrMaxforVtx<0)SetNMaxTrForVtx(3); //DEFAULT : NO SELECTION + if(fsignalInvMassCut<0.||flargeInvMassCut<0.||fsidebandInvMassCut<0.||fsidebandInvMassWindow<0.){ + printf("AliAnalysisTaskSECharmFraction: Not All info for mass selection provided: switch to default values \n"); + SetStandardMassSelection(); } + + AliRDHFCutsD0toKpi* copyfCutsTight=new AliRDHFCutsD0toKpi(*fCutsTight); + const char* nameoutputTight=GetOutputSlot(21)->GetContainer()->GetName(); + copyfCutsTight->SetName(nameoutputTight); + AliRDHFCutsD0toKpi* copyfCutsLoose=new AliRDHFCutsD0toKpi(*fCutsLoose); + const char* nameoutputLoose=GetOutputSlot(22)->GetContainer()->GetName(); + copyfCutsLoose->SetName(nameoutputLoose); + // Post the data + PostData(21,copyfCutsTight); + PostData(22,copyfCutsLoose); + return; } @@ -375,14 +418,17 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() TString namehist; TString titlehist; TString strnamept,strtitlept; - + Printf("INSIDE USER CREATE \n"); fNentries=new TH1F("nentriesChFr", "Look at the number of entries! = number of AODs", 2,1.,2.); - fSignalType=new TH1F("hsignaltype", "Histo for type of MC signal", 21,-1.,20.); - fSignalTypeLsCuts=new TH1F("hsignaltypeLsCuts", "Histo for type of MC signal with loose cuts", 21,-1.,20.); - fSignalTypeTghCuts=new TH1F("hsignaltypeTghCuts", "Histo for type of MC signal with tight cuts", 21,-1.,20.); + fSignalType=new TH1F("hsignaltype", "Histo for type of MC signal", 61,-1.,60.); + fSignalTypeLsCuts=new TH1F("hsignaltypeLsCuts", "Histo for type of MC signal with loose cuts", 61,-1.,60.); + fSignalTypeTghCuts=new TH1F("hsignaltypeTghCuts", "Histo for type of MC signal with tight cuts", 61,-1.,60.); //########## DEFINE THE TLISTS ################## - + flistMCproperties=new TList(); + flistMCproperties->SetOwner(); + flistMCproperties->SetName("listMCproperties"); + flistNoCutsSignal = new TList(); flistNoCutsSignal->SetOwner(); flistNoCutsSignal->SetName("listNCsign"); @@ -447,25 +493,99 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() + Float_t ptbinsD0arr[35]={0.,0.1,0.2,0.3,0.4,0.5,0.6,0.8,1.,1.25,1.5,1.75,2.,2.3,2.6,3.,3.5,4.,4.5,5.,5.5,6.,7.,8.,9.,10.,12.,14.,16.,20.,25.,30.,40.,50.,100.}; + Float_t dumbinning[201]; + for(Int_t j=0;j<201;j++){ + dumbinning[j]=(Float_t)j*0.5; + } + //################################################################################################ + // # + // HISTO FOR MC PROPERTIES OF D0, c quarks and B mesons # + // # + //################################################################################################ + TH1F *hMCcquarkAllPt=new TH1F("hMCcquarkAllPt","c quark Pt (all cquarks produced)",34,ptbinsD0arr); + TH1F *hMCcquarkAllEta=new TH1F("hMCcquarkAllEta","c quark Eta (all cquarks produced)",50,-3.,3.); + TH1F *hMCcquarkAllEnergy=new TH1F("hMCcquarkAllEnergy","c quark Pt (all cquarks produced)",200,0.,100.); + TH1F *hMCcquarkNdaught=new TH1F("hMCcquarkNdaught","N cquark daughters (all cquarks produced)",100,0.,100.); + TH1F *hMCD0fromcPt=new TH1F("hMCD0fromcPt","D0 from c Pt",34,ptbinsD0arr); + TH1F *hMCD0fromcEta=new TH1F("hMCD0fromcEta","D0 from c Eta",50,-3.,3.); + TH1F *hMCD0fromcEnergy=new TH1F("hMCD0fromcEnergy","D0 from c Energy",200,0.,100.); + + TH2F *hMCD0VscquarkPt=new TH2F("hMCD0VscquarkPt","D0 pt Vs cquark pt",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hMCD0VscquarkEnergy=new TH2F("hMCD0VscquarkEnergy","D0 Energy Vs cquark Energy",200,0.,50.,200,0.,50.); + TH1F *hMCD0deltacquarkEnergy=new TH1F("hMCD0deltacquarkEnergy","Fractional D0 Energy w.r.t. cquark Energy",20,0.,1.); + TH1F *hMCD0EnergyVsAvcquarkDaughtEn=new TH1F("hMCD0EnergyVsAvcquarkDaughtEn","#Delta(E^{D^0}-E_{avg})/E_{cquark}",40,-1.,1.); + TH1F *hMCD0cquarkAngle=new TH1F("hMCD0cquarkAngle","cosine of the angle between D0 and c quark particle",40,-1.,1.); + TH2F *hMCD0cquarkAngleEnergy=new TH2F("hMCD0cquarkAngleEnergy","cosine of the angle between D0 and c quark particle as a function of Energy",25,0.,50.,40,-1.,1.); + + TH1I *hMCfromBpdgB=new TH1I("hMCfromBpdgB","hMCfromBpdgB",10000,0.,10000); + TH1F *hMCBhadrPt=new TH1F("hMCBhadrPt","B hadr Pt",34,ptbinsD0arr); + TH1F *hMCBhadrEta=new TH1F("hMCBhadrEta","B hadr Eta",50,-3.,3.); + TH1F *hMCBhadrEnergy=new TH1F("hMCBhadrEnergy","B hadr Pt",200,0.,100.); + TH1F *hMCBhadrNdaught=new TH1F("hMCBhadrNdaught","N Bhadr daughters",100,0.,100.); + TH1F *hMCD0fromBPt=new TH1F("hMCD0fromBPt","D0 from B Pt",34,ptbinsD0arr); + TH1F *hMCD0fromBEta=new TH1F("hMCD0fromBEta","D0 from B Eta",50,-3.,3.); + TH1F *hMCD0fromBEnergy=new TH1F("hMCD0fromBEnergy","D0 from B Energy",200,0.,100.); + + TH2F *hMCD0VsBhadrPt=new TH2F("hMCD0VsBhadrPt","D0 pt Vs Bhadr pt",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hMCD0VsBhadrEnergy=new TH2F("hMCD0VsBhadrEnergy","D0 Energy Vs Bhadr Energy",200,0.,50.,200,0.,50.); + TH1F *hMCD0deltaBhadrEnergy=new TH1F("hMCD0deltaBhadrEnergy","Fractional D0 Energy w.r.t. Bhadr Energy",20,0.,1.); + TH1F *hMCD0EnergyVsAvBDaughtEn=new TH1F("hMCD0EnergyVsAvBDaughtEn","#Delta(E^{D^0}-E_{avg})/E_{Bahdr}",40,-1.,1.); + TH1F *hMCD0BhadrAngle=new TH1F("hMCD0BhadrAngle","cosine of the angle between D0 and Bhadr particle",40,-1.,1.); + TH2F *hMCD0BhadrAngleEnergy=new TH2F("hMCD0BhadrAngleEnergy","cosine of the angle between D0 and Bhadr particle as a function of Energy",25,0.,50.,40,-1.,1.); + + TH1I *hMCPartFound=new TH1I("hMCPartFound","1=c,2=D0,3=fromBall,4=fromBmeson,5=fromBbaryon",6,0,6); + + + flistMCproperties->Add(hMCcquarkAllPt); + flistMCproperties->Add(hMCcquarkAllEta); + flistMCproperties->Add(hMCcquarkAllEnergy); + flistMCproperties->Add(hMCcquarkNdaught); + flistMCproperties->Add(hMCD0fromcPt); + flistMCproperties->Add(hMCD0fromcEta); + flistMCproperties->Add(hMCD0fromcEnergy); + flistMCproperties->Add(hMCD0VscquarkPt); + flistMCproperties->Add(hMCD0VscquarkEnergy); + flistMCproperties->Add(hMCD0deltacquarkEnergy); + flistMCproperties->Add(hMCD0EnergyVsAvcquarkDaughtEn); + flistMCproperties->Add(hMCD0cquarkAngle); + flistMCproperties->Add(hMCD0cquarkAngleEnergy); + + flistMCproperties->Add(hMCfromBpdgB); + flistMCproperties->Add(hMCBhadrPt); + flistMCproperties->Add(hMCBhadrEta); + flistMCproperties->Add(hMCBhadrEnergy); + flistMCproperties->Add(hMCBhadrNdaught); + flistMCproperties->Add(hMCD0fromBPt); + flistMCproperties->Add(hMCD0fromBEta); + flistMCproperties->Add(hMCD0fromBEnergy); + flistMCproperties->Add(hMCD0VsBhadrPt); + flistMCproperties->Add(hMCD0VsBhadrEnergy); + flistMCproperties->Add(hMCD0deltaBhadrEnergy); + flistMCproperties->Add(hMCD0EnergyVsAvBDaughtEn); + flistMCproperties->Add(hMCD0BhadrAngle); + flistMCproperties->Add(hMCD0BhadrAngleEnergy); + flistMCproperties->Add(hMCPartFound); //################################################################################################ // # // HISTOS FOR NO CUTS CASE # // # //################################################################################################ - + Printf("AFTER MC HISTOS \n"); //############ NO CUTS SIGNAL HISTOGRAMS ############### // // ####### global properties histo ############ - TH2F *hCPtaVSd0d0NCsign=new TH2F("hCPtaVSd0d0NCsign","hCPtaVSd0d0_NoCuts_Signal",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0NCsign=new TH2F("hCPtaVSd0d0NCsign","hCPtaVSd0d0_NoCuts_Signal",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZNCsign=new TH1F("hSecVtxZNCsign","hSecVtxZ_NoCuts_Signal",1000,-8.,8.); TH1F *hSecVtxXNCsign=new TH1F("hSecVtxXNCsign","hSecVtxX_NoCuts_Signal",1000,-3000.,3000.); TH1F *hSecVtxYNCsign=new TH1F("hSecVtxYNCsign","hSecVtxY_NoCuts_Signal",1000,-3000.,3000.); TH2F *hSecVtxXYNCsign=new TH2F("hSecVtxXYNCsign","hSecVtxXY_NoCuts_Signal",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiNCsign=new TH1F("hSecVtxPhiNCsign","hSecVtxPhi_NoCuts_Signal",180,-180.1,180.1); - TH1F *hCPtaNCsign=new TH1F("hCPtaNCsign","hCPta_NoCuts_Signal",100,0.,1.); + TH1F *hd0singlTrackNCsign=new TH1F("hd0singlTrackNCsign","hd0singlTrackNoCuts_Signal",1000,-5000.,5000.); + TH1F *hCPtaNCsign=new TH1F("hCPtaNCsign","hCPta_NoCuts_Signal",100,-1.,1.); TH1F *hd0xd0NCsign=new TH1F("hd0xd0NCsign","hd0xd0_NoCuts_Signal",1000,-100000.,100000.); TH1F *hMassTrueNCsign=new TH1F("hMassTrueNCsign","D^{0} MC inv. Mass No Cuts Signal(All momenta)",600,1.600,2.200); TH1F *hMassNCsign=new TH1F("hMassNCsign","D^{0} inv. Mass No Cuts Signal (All momenta)",600,1.600,2.200); @@ -484,6 +604,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsSignal->Add(hSecVtxXNCsign); flistNoCutsSignal->Add(hSecVtxXYNCsign); flistNoCutsSignal->Add(hSecVtxPhiNCsign); + flistNoCutsSignal->Add(hd0singlTrackNCsign); flistNoCutsSignal->Add(hCPtaNCsign); flistNoCutsSignal->Add(hd0xd0NCsign); flistNoCutsSignal->Add(hMassTrueNCsign); @@ -492,6 +613,145 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsSignal->Add(hMassNCsignPM); flistNoCutsSignal->Add(hMassTrueNCsignSB); flistNoCutsSignal->Add(hMassNCsignSB); + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaNCsign=new TH1F("hdcaNCsign","hdca_NoCuts_Signal",100,0.,1000.); + hdcaNCsign->SetXTitle("dca [#mum]"); + hdcaNCsign->SetYTitle("Entries"); + TH1F *hcosthetastarNCsign=new TH1F("hcosthetastarNCsign","hCosThetaStar_NoCuts_Signal",50,-1.,1.); + hcosthetastarNCsign->SetXTitle("cos #theta^{*}"); + hcosthetastarNCsign->SetYTitle("Entries"); + TH1F *hptD0NCsign=new TH1F("hptD0NCsign","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0NCsign->SetXTitle("p_{t} [GeV/c]"); + hptD0NCsign->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtNCsign=new TH1F("hptD0VsMaxPtNCsign","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtNCsign=new TH2F("hptD0PTallsqrtNCsign","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallNCsign=new TH2F("hptD0PTallNCsign","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBNCsign=new TH2F("hptD0vsptBNCsign","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBNCsign=new TH2F("hpD0vspBNCsign","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkNCsign=new TH2F("hptD0vsptcquarkNCsign","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkNCsign=new TH2F("hpD0vspcquarkNCsign","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistNoCutsSignal->Add(hdcaNCsign); + flistNoCutsSignal->Add(hcosthetastarNCsign); + flistNoCutsSignal->Add(hptD0NCsign); + flistNoCutsSignal->Add(hptD0VsMaxPtNCsign); + flistNoCutsSignal->Add(hptD0PTallsqrtNCsign); + flistNoCutsSignal->Add(hptD0PTallNCsign); + flistNoCutsSignal->Add(hptD0vsptBNCsign); + flistNoCutsSignal->Add(hpD0vspBNCsign); + flistNoCutsSignal->Add(hptD0vsptcquarkNCsign); + flistNoCutsSignal->Add(hpD0vspcquarkNCsign); + + TH1F *hd0zD0ptNCsign; + TH1F *hInvMassNCsign; + TH2F *hInvMassPtNCsign=new TH2F("hInvMassPtNCsign","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + flistNoCutsSignal->Add(hInvMassPtNCsign); + TH1F *hetaNCsign; + TH1F *hCosPDPBNCsign; + TH1F *hCosPcPDNCsign; + // ADDITIONAL HISTOS + TH2F *hd0D0VSd0xd0NCsignpt; + TH2F *hangletracksVSd0xd0NCsignpt; + TH2F *hangletracksVSd0D0NCsignpt; + TH1F *hd0xd0NCsignpt; + + TH2F *hTOFpidNCsign=new TH2F("hTOFpidNCsign","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistNoCutsSignal->Add(hTOFpidNCsign); + + //################## + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptNCsign->SetYTitle("Entries"); + flistNoCutsSignal->Add(hd0zD0ptNCsign); + + namehist="hInvMassNCsign_pt"; + namehist+=i; + titlehist="Invariant Mass No Cuts Signal ptbin="; + titlehist+=i; + hInvMassNCsign=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassNCsign->SetXTitle("Invariant Mass [GeV]"); + hInvMassNCsign->SetYTitle("Entries"); + flistNoCutsSignal->Add(hInvMassNCsign); + + namehist="hetaNCsign_pt"; + namehist+=i; + titlehist="eta No Cuts Signal ptbin="; + titlehist+=i; + hetaNCsign=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaNCsign->SetXTitle("Pseudorapidity"); + hetaNCsign->SetYTitle("Entries"); + flistNoCutsSignal->Add(hetaNCsign); + + namehist="hCosPDPBNCsign_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBNCsign=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBNCsign->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBNCsign->SetYTitle("Entries"); + flistNoCutsSignal->Add(hCosPDPBNCsign); + + namehist="hCosPcPDNCsign_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDNCsign=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDNCsign->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDNCsign->SetYTitle("Entries"); + flistNoCutsSignal->Add(hCosPcPDNCsign); + + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0NCsign_pt"; + namehist+=i; + titlehist="d0xd0 No Cuts Signal ptbin="; + titlehist+=i; + hd0xd0NCsignpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0NCsignpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0NCsignpt->SetYTitle("Entries"); + flistNoCutsSignal->Add(hd0xd0NCsignpt); + + + namehist="hd0D0VSd0xd0NCsign_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} No Cuts Signal ptbin="; + titlehist+=i; + hd0D0VSd0xd0NCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0NCsignpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0NCsignpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistNoCutsSignal->Add(hd0D0VSd0xd0NCsignpt); + + + namehist="hangletracksVSd0xd0NCsign_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} No Cuts Signal ptbin="; + titlehist+=i; + hangletracksVSd0xd0NCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0NCsignpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0NCsignpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsSignal->Add(hangletracksVSd0xd0NCsignpt); + + + namehist="hangletracksVSd0D0NCsign_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} No Cuts Signal ptbin="; + titlehist+=i; + hangletracksVSd0D0NCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0NCsignpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0NCsignpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsSignal->Add(hangletracksVSd0D0NCsignpt); + + } + Printf("AFTER LOOP HISTOS CREATION \n"); + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% // ####### d0 D0 histos ############ TH1F *hd0D0NCsignPM = new TH1F("hd0D0NCsignPM","D^{0} impact par. plot , No Cuts ,Signal,Mass Peak (All momenta)",1000,-1000.,1000.); @@ -525,43 +785,46 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsSignal->Add(hd0D0VtxTrueNCsignSB); flistNoCutsSignal->Add(hMCd0D0NCsignSB); - TH1F **hd0D0ptNCsignPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCsignPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCsignPM=new TH1F*[fnbins]; - TH1F **hd0D0ptNCsignSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCsignSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCsignSB=new TH1F*[fnbins]; + TH1F *hd0D0ptNCsignPM; + TH1F *hMCd0D0ptNCsignPM; + TH1F *hd0D0VtxTrueptNCsignPM; + TH1F *hd0D0ptNCsignSB; + TH1F *hMCd0D0ptNCsignSB; + TH1F *hd0D0VtxTrueptNCsignSB; namehist="hd0D0ptNCsign_"; titlehist="D^{0} impact par. plot, No Cuts, Signal, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptNCsignPM[i]->SetYTitle("Entries"); - flistNoCutsSignal->Add(hd0D0ptNCsignPM[i]); + hd0D0ptNCsignPM= new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCsignPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCsignPM->SetYTitle("Entries"); + flistNoCutsSignal->Add(hd0D0ptNCsignPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCsignPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCsignPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCsignPM[i]->SetYTitle("Entries"); - flistNoCutsSignal->Add(hMCd0D0ptNCsignPM[i]); + hMCd0D0ptNCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCsignPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCsignPM->SetYTitle("Entries"); + flistNoCutsSignal->Add(hMCd0D0ptNCsignPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCsignPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCsignPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCsignPM[i]->SetYTitle("Entries"); - flistNoCutsSignal->Add(hd0D0VtxTrueptNCsignPM[i]); + hd0D0VtxTrueptNCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCsignPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCsignPM->SetYTitle("Entries"); + flistNoCutsSignal->Add(hd0D0VtxTrueptNCsignPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -574,35 +837,38 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptNCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptNCsignSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptNCsignSB[i]->SetYTitle("Entries"); - flistNoCutsSignal->Add(hd0D0ptNCsignSB[i]); + hd0D0ptNCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCsignSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCsignSB->SetYTitle("Entries"); + flistNoCutsSignal->Add(hd0D0ptNCsignSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCsignSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCsignSB[i]->SetYTitle("Entries"); - flistNoCutsSignal->Add(hMCd0D0ptNCsignSB[i]); + hMCd0D0ptNCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCsignSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCsignSB->SetYTitle("Entries"); + flistNoCutsSignal->Add(hMCd0D0ptNCsignSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCsignSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCsignSB[i]->SetYTitle("Entries"); - flistNoCutsSignal->Add(hd0D0VtxTrueptNCsignSB[i]); + hd0D0VtxTrueptNCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCsignSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCsignSB->SetYTitle("Entries"); + flistNoCutsSignal->Add(hd0D0VtxTrueptNCsignSB); } + Printf("AFTER SIGNAL HISTOS CREATION for NOCUTS\n"); + //############ NO CUTS BACKGROUND HISTOGRAMS ########### // // ######## global properties histos ####### - TH2F *hCPtaVSd0d0NCback=new TH2F("hCPtaVSd0d0NCback","hCPtaVSd0d0_NoCuts_Background",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0NCback=new TH2F("hCPtaVSd0d0NCback","hCPtaVSd0d0_NoCuts_Background",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZNCback=new TH1F("hSecVtxZNCback","hSecVtxZ_NoCuts_Background",1000,-8.,8.); TH1F *hSecVtxXNCback=new TH1F("hSecVtxXNCback","hSecVtxX_NoCuts_Background",1000,-3000.,3000.); TH1F *hSecVtxYNCback=new TH1F("hSecVtxYNCback","hSecVtxY_NoCuts_Background",1000,-3000.,3000.); TH2F *hSecVtxXYNCback=new TH2F("hSecVtxXYNCback","hSecVtxXY_NoCuts_Background",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiNCback=new TH1F("hSecVtxPhiNCback","hSecVtxPhi_NoCuts_Background",180,-180.1,180.1); - TH1F *hCPtaNCback=new TH1F("hCPtaNCback","hCPta_NoCuts_Background",100,0.,1.); + TH1F *hd0singlTrackNCback=new TH1F("hd0singlTrackNCback","hd0singlTrackNoCuts_Back",1000,-5000.,5000.); + TH1F *hCPtaNCback=new TH1F("hCPtaNCback","hCPta_NoCuts_Background",100,-1.,1.); TH1F *hd0xd0NCback=new TH1F("hd0xd0NCback","hd0xd0_NoCuts_Background",1000,-100000.,100000.); TH1F *hMassTrueNCback=new TH1F("hMassTrueNCback","D^{0} MC inv. Mass No Cuts Background(All momenta)",600,1.600,2.200); TH1F *hMassNCback=new TH1F("hMassNCback","D^{0} inv. Mass No Cuts Background (All momenta)",600,1.600,2.200); @@ -620,6 +886,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsBack->Add(hSecVtxXNCback); flistNoCutsBack->Add(hSecVtxXYNCback); flistNoCutsBack->Add(hSecVtxPhiNCback); + flistNoCutsBack->Add(hd0singlTrackNCback); flistNoCutsBack->Add(hCPtaNCback); flistNoCutsBack->Add(hd0xd0NCback); flistNoCutsBack->Add(hMassTrueNCback); @@ -630,6 +897,145 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsBack->Add(hMassNCbackSB); + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaNCback=new TH1F("hdcaNCback","hdca_NoCuts_Backgr",100,0.,1000.); + hdcaNCback->SetXTitle("dca [#mum]"); + hdcaNCback->SetYTitle("Entries"); + TH1F *hcosthetastarNCback=new TH1F("hcosthetastarNCback","hCosThetaStar_NoCuts_Backgr",50,-1.,1.); + hcosthetastarNCback->SetXTitle("cos #theta^{*}"); + hcosthetastarNCback->SetYTitle("Entries"); + TH1F *hptD0NCback=new TH1F("hptD0NCback","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0NCback->SetXTitle("p_{t} [GeV/c]"); + hptD0NCback->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtNCback=new TH1F("hptD0VsMaxPtNCback","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtNCback=new TH2F("hptD0PTallsqrtNCback","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallNCback=new TH2F("hptD0PTallNCback","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBNCback=new TH2F("hptD0vsptBNCback","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBNCback=new TH2F("hpD0vspBNCback","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkNCback=new TH2F("hptD0vsptcquarkNCback","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkNCback=new TH2F("hpD0vspcquarkNCback","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistNoCutsBack->Add(hdcaNCback); + flistNoCutsBack->Add(hcosthetastarNCback); + flistNoCutsBack->Add(hptD0NCback); + flistNoCutsBack->Add(hptD0VsMaxPtNCback); + flistNoCutsBack->Add(hptD0PTallsqrtNCback); + flistNoCutsBack->Add(hptD0PTallNCback); + flistNoCutsBack->Add(hptD0vsptBNCback); + flistNoCutsBack->Add(hpD0vspBNCback); + flistNoCutsBack->Add(hptD0vsptcquarkNCback); + flistNoCutsBack->Add(hpD0vspcquarkNCback); + + TH1F *hd0zD0ptNCback; + TH1F *hInvMassNCback; + TH2F *hInvMassPtNCback=new TH2F("hInvMassPtNCback","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaNCback; + TH1F *hCosPDPBNCback; + TH1F *hCosPcPDNCback; + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0NCbackpt; + TH2F *hangletracksVSd0xd0NCbackpt; + TH2F *hangletracksVSd0D0NCbackpt; + TH1F *hd0xd0NCbackpt; + flistNoCutsBack->Add(hInvMassPtNCback); + + TH2F *hTOFpidNCback=new TH2F("hTOFpidNCback","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistNoCutsBack->Add(hTOFpidNCback); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptNCback->SetYTitle("Entries"); + flistNoCutsBack->Add(hd0zD0ptNCback); + + namehist="hInvMassNCback_pt"; + namehist+=i; + titlehist="Invariant Mass No Cuts Backgr ptbin="; + titlehist+=i; + hInvMassNCback=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassNCback->SetXTitle("Invariant Mass [GeV]"); + hInvMassNCback->SetYTitle("Entries"); + flistNoCutsBack->Add(hInvMassNCback); + + namehist="hetaNCback_pt"; + namehist+=i; + titlehist="eta No Cuts Backgr ptbin="; + titlehist+=i; + hetaNCback=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaNCback->SetXTitle("Pseudorapidity"); + hetaNCback->SetYTitle("Entries"); + flistNoCutsBack->Add(hetaNCback); + + namehist="hCosPDPBNCback_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBNCback=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBNCback->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBNCback->SetYTitle("Entries"); + flistNoCutsBack->Add(hCosPDPBNCback); + + namehist="hCosPcPDNCback_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDNCback=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDNCback->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDNCback->SetYTitle("Entries"); + flistNoCutsBack->Add(hCosPcPDNCback); + + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0NCback_pt"; + namehist+=i; + titlehist="d0xd0 No Cuts Background ptbin="; + titlehist+=i; + hd0xd0NCbackpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0NCbackpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0NCbackpt->SetYTitle("Entries"); + flistNoCutsBack->Add(hd0xd0NCbackpt); + + + namehist="hd0D0VSd0xd0NCback_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} No Cuts Back ptbin="; + titlehist+=i; + hd0D0VSd0xd0NCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0NCbackpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0NCbackpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistNoCutsBack->Add(hd0D0VSd0xd0NCbackpt); + + + namehist="hangletracksVSd0xd0NCback_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} No Cuts Back ptbin="; + titlehist+=i; + hangletracksVSd0xd0NCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0NCbackpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0NCbackpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsBack->Add(hangletracksVSd0xd0NCbackpt); + + + namehist="hangletracksVSd0D0NCback_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} No Cuts Back ptbin="; + titlehist+=i; + hangletracksVSd0D0NCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0NCbackpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0NCbackpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsBack->Add(hangletracksVSd0D0NCbackpt); + + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + // ####### d0 D0 histos ############ TH1F *hd0D0NCbackPM = new TH1F("hd0D0NCbackPM","D^{0} impact par. plot , No Cuts ,Background,Mass Peak (All momenta)",1000,-1000.,1000.); @@ -663,12 +1069,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsBack->Add(hd0D0VtxTrueNCbackSB); flistNoCutsBack->Add(hMCd0D0NCbackSB); - TH1F **hd0D0ptNCbackPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCbackPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCbackPM=new TH1F*[fnbins]; - TH1F **hd0D0ptNCbackSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCbackSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCbackSB=new TH1F*[fnbins]; + TH1F *hd0D0ptNCbackPM; + TH1F *hMCd0D0ptNCbackPM; + TH1F *hd0D0VtxTrueptNCbackPM; + TH1F *hd0D0ptNCbackSB; + TH1F *hMCd0D0ptNCbackSB; + TH1F *hd0D0VtxTrueptNCbackSB; namehist="hd0D0ptNCback_"; titlehist="D^{0} impact par. plot, No Cuts, Background, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptNCbackPM[i]->SetYTitle("Entries"); - flistNoCutsBack->Add(hd0D0ptNCbackPM[i]); + hd0D0ptNCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCbackPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCbackPM->SetYTitle("Entries"); + flistNoCutsBack->Add(hd0D0ptNCbackPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCbackPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCbackPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCbackPM[i]->SetYTitle("Entries"); - flistNoCutsBack->Add(hMCd0D0ptNCbackPM[i]); + hMCd0D0ptNCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCbackPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCbackPM->SetYTitle("Entries"); + flistNoCutsBack->Add(hMCd0D0ptNCbackPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCbackPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCbackPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCbackPM[i]->SetYTitle("Entries"); - flistNoCutsBack->Add(hd0D0VtxTrueptNCbackPM[i]); + hd0D0VtxTrueptNCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCbackPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCbackPM->SetYTitle("Entries"); + flistNoCutsBack->Add(hd0D0VtxTrueptNCbackPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -712,22 +1118,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptNCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptNCbackSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptNCbackSB[i]->SetYTitle("Entries"); - flistNoCutsBack->Add(hd0D0ptNCbackSB[i]); + hd0D0ptNCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCbackSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCbackSB->SetYTitle("Entries"); + flistNoCutsBack->Add(hd0D0ptNCbackSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCbackSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCbackSB[i]->SetYTitle("Entries"); - flistNoCutsBack->Add(hMCd0D0ptNCbackSB[i]); + hMCd0D0ptNCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCbackSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCbackSB->SetYTitle("Entries"); + flistNoCutsBack->Add(hMCd0D0ptNCbackSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCbackSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCbackSB[i]->SetYTitle("Entries"); - flistNoCutsBack->Add(hd0D0VtxTrueptNCbackSB[i]); + hd0D0VtxTrueptNCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCbackSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCbackSB->SetYTitle("Entries"); + flistNoCutsBack->Add(hd0D0VtxTrueptNCbackSB); } @@ -736,13 +1142,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //####### global properties histos - TH2F *hCPtaVSd0d0NCfromB=new TH2F("hCPtaVSd0d0NCfromB","hCPtaVSd0d0_NoCuts_FromB",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0NCfromB=new TH2F("hCPtaVSd0d0NCfromB","hCPtaVSd0d0_NoCuts_FromB",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZNCfromB=new TH1F("hSecVtxZNCfromB","hSecVtxZ_NoCuts_FromB",1000,-8.,8.); TH1F *hSecVtxXNCfromB=new TH1F("hSecVtxXNCfromB","hSecVtxX_NoCuts_FromB",1000,-3000.,3000.); TH1F *hSecVtxYNCfromB=new TH1F("hSecVtxYNCfromB","hSecVtxY_NoCuts_FromB",1000,-3000.,3000.); TH2F *hSecVtxXYNCfromB=new TH2F("hSecVtxXYNCfromB","hSecVtxXY_NoCuts_FromB",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiNCfromB=new TH1F("hSecVtxPhiNCfromB","hSecVtxPhi_NoCuts_FromB",180,-180.1,180.1); - TH1F *hCPtaNCfromB=new TH1F("hCPtaNCfromB","hCPta_NoCuts_FromB",100,0.,1.); + TH1F *hd0singlTrackNCfromB=new TH1F("hd0singlTrackNCfromB","hd0singlTrackNoCuts_FromB",1000,-5000.,5000.); + TH1F *hCPtaNCfromB=new TH1F("hCPtaNCfromB","hCPta_NoCuts_FromB",100,-1.,1.); TH1F *hd0xd0NCfromB=new TH1F("hd0xd0NCfromB","hd0xd0_NoCuts_FromB",1000,-100000.,100000.); TH1F *hMassTrueNCfromB=new TH1F("hMassTrueNCfromB","D^{0} MC inv. Mass No Cuts FromB(All momenta)",600,1.600,2.200); TH1F *hMassNCfromB=new TH1F("hMassNCfromB","D^{0} inv. Mass No Cuts FromB (All momenta)",600,1.600,2.200); @@ -760,6 +1167,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsFromB->Add(hSecVtxXNCfromB); flistNoCutsFromB->Add(hSecVtxXYNCfromB); flistNoCutsFromB->Add(hSecVtxPhiNCfromB); + flistNoCutsFromB->Add(hd0singlTrackNCfromB); flistNoCutsFromB->Add(hCPtaNCfromB); flistNoCutsFromB->Add(hd0xd0NCfromB); flistNoCutsFromB->Add(hMassTrueNCfromB); @@ -769,6 +1177,148 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsFromB->Add(hMassTrueNCfromBSB); flistNoCutsFromB->Add(hMassNCfromBSB); + + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaNCfromB=new TH1F("hdcaNCfromB","hdca_NoCuts_FromB",100,0.,1000.); + hdcaNCfromB->SetXTitle("dca [#mum]"); + hdcaNCfromB->SetYTitle("Entries"); + TH1F *hcosthetastarNCfromB=new TH1F("hcosthetastarNCfromB","hCosThetaStar_NoCuts_FromB",50,-1.,1.); + hcosthetastarNCfromB->SetXTitle("cos #theta^{*}"); + hcosthetastarNCfromB->SetYTitle("Entries"); + TH1F *hptD0NCfromB=new TH1F("hptD0NCfromB","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0NCfromB->SetXTitle("p_{t} [GeV/c]"); + hptD0NCfromB->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtNCfromB=new TH1F("hptD0VsMaxPtNCfromB","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtNCfromB=new TH2F("hptD0PTallsqrtNCfromB","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallNCfromB=new TH2F("hptD0PTallNCfromB","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBNCfromB=new TH2F("hptD0vsptBNCfromB","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBNCfromB=new TH2F("hpD0vspBNCfromB","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkNCfromB=new TH2F("hptD0vsptcquarkNCfromB","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkNCfromB=new TH2F("hpD0vspcquarkNCfromB","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistNoCutsFromB->Add(hdcaNCfromB); + flistNoCutsFromB->Add(hcosthetastarNCfromB); + flistNoCutsFromB->Add(hptD0NCfromB); + flistNoCutsFromB->Add(hptD0VsMaxPtNCfromB); + flistNoCutsFromB->Add(hptD0PTallsqrtNCfromB); + flistNoCutsFromB->Add(hptD0PTallNCfromB); + flistNoCutsFromB->Add(hptD0vsptBNCfromB); + flistNoCutsFromB->Add(hpD0vspBNCfromB); + flistNoCutsFromB->Add(hptD0vsptcquarkNCfromB); + flistNoCutsFromB->Add(hpD0vspcquarkNCfromB); + + TH1F *hd0zD0ptNCfromB; + TH1F *hInvMassNCfromB; + TH2F *hInvMassPtNCfromB=new TH2F("hInvMassPtNCfromB","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaNCfromB; + TH1F *hCosPDPBNCfromB; + TH1F *hCosPcPDNCfromB; + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0NCfromBpt; + TH2F *hangletracksVSd0xd0NCfromBpt; + TH2F *hangletracksVSd0D0NCfromBpt; + TH1F *hd0xd0NCfromBpt; + flistNoCutsFromB->Add(hInvMassPtNCfromB); + + TH2F *hTOFpidNCfromB=new TH2F("hTOFpidNCfromB","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistNoCutsFromB->Add(hTOFpidNCfromB); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptNCfromB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hd0zD0ptNCfromB); + + namehist="hInvMassNCfromB_pt"; + namehist+=i; + titlehist="Invariant Mass No Cuts FromB ptbin="; + titlehist+=i; + hInvMassNCfromB=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassNCfromB->SetXTitle("Invariant Mass [GeV]"); + hInvMassNCfromB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hInvMassNCfromB); + + namehist="hetaNCfromB_pt"; + namehist+=i; + titlehist="eta No Cuts FromB ptbin="; + titlehist+=i; + hetaNCfromB=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaNCfromB->SetXTitle("Pseudorapidity"); + hetaNCfromB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hetaNCfromB); + + namehist="hCosPDPBNCfromB_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBNCfromB=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBNCfromB->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBNCfromB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hCosPDPBNCfromB); + + namehist="hCosPcPDNCfromB_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDNCfromB=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDNCfromB->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDNCfromB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hCosPcPDNCfromB); + +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0NCfromB_pt"; + namehist+=i; + titlehist="d0xd0 No Cuts FromB ptbin="; + titlehist+=i; + hd0xd0NCfromBpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0NCfromBpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0NCfromBpt->SetYTitle("Entries"); + flistNoCutsFromB->Add(hd0xd0NCfromBpt); + + + namehist="hd0D0VSd0xd0NCfromB_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} No Cuts FromB ptbin="; + titlehist+=i; + hd0D0VSd0xd0NCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0NCfromBpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0NCfromBpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistNoCutsFromB->Add(hd0D0VSd0xd0NCfromBpt); + + + namehist="hangletracksVSd0xd0NCfromB_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} No Cuts FromB ptbin="; + titlehist+=i; + hangletracksVSd0xd0NCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0NCfromBpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0NCfromBpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsFromB->Add(hangletracksVSd0xd0NCfromBpt); + + + namehist="hangletracksVSd0D0NCfromB_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} No Cuts FromB ptbin="; + titlehist+=i; + hangletracksVSd0D0NCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0NCfromBpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0NCfromBpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsFromB->Add(hangletracksVSd0D0NCfromBpt); + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + // ######### d0 D0 histos ############## TH1F *hd0D0NCfromBPM = new TH1F("hd0D0NCfromBPM","D^{0} impact par. plot , No Cuts ,FromB,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0NCfromBPM->SetXTitle("Impact parameter [#mum]"); @@ -801,12 +1351,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsFromB->Add(hd0D0VtxTrueNCfromBSB); flistNoCutsFromB->Add(hMCd0D0NCfromBSB); - TH1F **hd0D0ptNCfromBPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCfromBPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCfromBPM=new TH1F*[fnbins]; - TH1F **hd0D0ptNCfromBSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCfromBSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCfromBSB=new TH1F*[fnbins]; + TH1F *hd0D0ptNCfromBPM; + TH1F *hMCd0D0ptNCfromBPM; + TH1F *hd0D0VtxTrueptNCfromBPM; + TH1F *hd0D0ptNCfromBSB; + TH1F *hMCd0D0ptNCfromBSB; + TH1F *hd0D0VtxTrueptNCfromBSB; namehist="hd0D0ptNCfromB_"; titlehist="D^{0} impact par. plot, No Cuts, FromB, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptNCfromBPM[i]->SetYTitle("Entries"); - flistNoCutsFromB->Add(hd0D0ptNCfromBPM[i]); + hd0D0ptNCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCfromBPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCfromBPM->SetYTitle("Entries"); + flistNoCutsFromB->Add(hd0D0ptNCfromBPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCfromBPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCfromBPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCfromBPM[i]->SetYTitle("Entries"); - flistNoCutsFromB->Add(hMCd0D0ptNCfromBPM[i]); + hMCd0D0ptNCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCfromBPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCfromBPM->SetYTitle("Entries"); + flistNoCutsFromB->Add(hMCd0D0ptNCfromBPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCfromBPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCfromBPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCfromBPM[i]->SetYTitle("Entries"); - flistNoCutsFromB->Add(hd0D0VtxTrueptNCfromBPM[i]); + hd0D0VtxTrueptNCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCfromBPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCfromBPM->SetYTitle("Entries"); + flistNoCutsFromB->Add(hd0D0VtxTrueptNCfromBPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -850,22 +1400,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptNCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptNCfromBSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptNCfromBSB[i]->SetYTitle("Entries"); - flistNoCutsFromB->Add(hd0D0ptNCfromBSB[i]); + hd0D0ptNCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCfromBSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCfromBSB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hd0D0ptNCfromBSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCfromBSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCfromBSB[i]->SetYTitle("Entries"); - flistNoCutsFromB->Add(hMCd0D0ptNCfromBSB[i]); + hMCd0D0ptNCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCfromBSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCfromBSB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hMCd0D0ptNCfromBSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCfromBSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCfromBSB[i]->SetYTitle("Entries"); - flistNoCutsFromB->Add(hd0D0VtxTrueptNCfromBSB[i]); + hd0D0VtxTrueptNCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCfromBSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCfromBSB->SetYTitle("Entries"); + flistNoCutsFromB->Add(hd0D0VtxTrueptNCfromBSB); } @@ -874,13 +1424,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //############# global properties histos ####### - TH2F *hCPtaVSd0d0NCfromDstar=new TH2F("hCPtaVSd0d0NCfromDstar","hCPtaVSd0d0_NoCuts_FromDStar",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0NCfromDstar=new TH2F("hCPtaVSd0d0NCfromDstar","hCPtaVSd0d0_NoCuts_FromDStar",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZNCfromDstar=new TH1F("hSecVtxZNCfromDstar","hSecVtxZ_NoCuts_FromDStar",1000,-8.,8.); TH1F *hSecVtxXNCfromDstar=new TH1F("hSecVtxXNCfromDstar","hSecVtxX_NoCuts_FromDStar",1000,-3000.,3000.); TH1F *hSecVtxYNCfromDstar=new TH1F("hSecVtxYNCfromDstar","hSecVtxY_NoCuts_FromDStar",1000,-3000.,3000.); TH2F *hSecVtxXYNCfromDstar=new TH2F("hSecVtxXYNCfromDstar","hSecVtxXY_NoCuts_FromDStar",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiNCfromDstar=new TH1F("hSecVtxPhiNCfromDstar","hSecVtxPhi_NoCuts_FromDStar",180,-180.1,180.1); - TH1F *hCPtaNCfromDstar=new TH1F("hCPtaNCfromDstar","hCPta_NoCuts_FromDStar",100,0.,1.); + TH1F *hd0singlTrackNCfromDstar=new TH1F("hd0singlTrackNCfromDstar","hd0singlTrackNoCuts_fromDstar",1000,-5000.,5000.); + TH1F *hCPtaNCfromDstar=new TH1F("hCPtaNCfromDstar","hCPta_NoCuts_FromDStar",100,-1.,1.); TH1F *hd0xd0NCfromDstar=new TH1F("hd0xd0NCfromDstar","hd0xd0_NoCuts_FromDStar",1000,-100000.,100000.); TH1F *hMassTrueNCfromDstar=new TH1F("hMassTrueNCfromDstar","D^{0} MC inv. Mass No Cuts FromDStar(All momenta)",600,1.600,2.200); TH1F *hMassNCfromDstar=new TH1F("hMassNCfromDstar","D^{0} inv. Mass No Cuts FromDStar (All momenta)",600,1.600,2.200); @@ -898,6 +1449,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsFromDstar->Add(hSecVtxXNCfromDstar); flistNoCutsFromDstar->Add(hSecVtxXYNCfromDstar); flistNoCutsFromDstar->Add(hSecVtxPhiNCfromDstar); + flistNoCutsFromDstar->Add(hd0singlTrackNCfromDstar); flistNoCutsFromDstar->Add(hCPtaNCfromDstar); flistNoCutsFromDstar->Add(hd0xd0NCfromDstar); flistNoCutsFromDstar->Add(hMassTrueNCfromDstar); @@ -907,6 +1459,144 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsFromDstar->Add(hMassTrueNCfromDstarSB); flistNoCutsFromDstar->Add(hMassNCfromDstarSB); + + + +//%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaNCfromDstar=new TH1F("hdcaNCfromDstar","hdca_NoCuts_FromDstar",100,0.,1000.); + hdcaNCfromDstar->SetXTitle("dca [#mum]"); + hdcaNCfromDstar->SetYTitle("Entries"); + TH1F *hcosthetastarNCfromDstar=new TH1F("hcosthetastarNCfromDstar","hCosThetaStar_NoCuts_FromDstar",50,-1.,1.); + hcosthetastarNCfromDstar->SetXTitle("cos #theta^{*}"); + hcosthetastarNCfromDstar->SetYTitle("Entries"); + TH1F *hptD0NCfromDstar=new TH1F("hptD0NCfromDstar","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0NCfromDstar->SetXTitle("p_{t} [GeV/c]"); + hptD0NCfromDstar->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtNCfromDstar=new TH1F("hptD0VsMaxPtNCfromDstar","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtNCfromDstar=new TH2F("hptD0PTallsqrtNCfromDstar","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallNCfromDstar=new TH2F("hptD0PTallNCfromDstar","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBNCfromDstar=new TH2F("hptD0vsptBNCfromDstar","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBNCfromDstar=new TH2F("hpD0vspBNCfromDstar","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkNCfromDstar=new TH2F("hptD0vsptcquarkNCfromDstar","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkNCfromDstar=new TH2F("hpD0vspcquarkNCfromDstar","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistNoCutsFromDstar->Add(hdcaNCfromDstar); + flistNoCutsFromDstar->Add(hcosthetastarNCfromDstar); + flistNoCutsFromDstar->Add(hptD0NCfromDstar); + flistNoCutsFromDstar->Add(hptD0VsMaxPtNCfromDstar); + flistNoCutsFromDstar->Add(hptD0PTallsqrtNCfromDstar); + flistNoCutsFromDstar->Add(hptD0PTallNCfromDstar); + flistNoCutsFromDstar->Add(hptD0vsptBNCfromDstar); + flistNoCutsFromDstar->Add(hpD0vspBNCfromDstar); + flistNoCutsFromDstar->Add(hptD0vsptcquarkNCfromDstar); + flistNoCutsFromDstar->Add(hpD0vspcquarkNCfromDstar); + + TH1F *hd0zD0ptNCfromDstar; + TH1F *hInvMassNCfromDstar; + TH2F *hInvMassPtNCfromDstar=new TH2F("hInvMassPtNCfromDstar","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaNCfromDstar; + TH1F *hCosPDPBNCfromDstar; + TH1F *hCosPcPDNCfromDstar; + flistNoCutsFromDstar->Add(hInvMassPtNCfromDstar); + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0NCfromDstarpt; + TH2F *hangletracksVSd0xd0NCfromDstarpt; + TH2F *hangletracksVSd0D0NCfromDstarpt; + TH1F *hd0xd0NCfromDstarpt; + + TH2F *hTOFpidNCfromDstar=new TH2F("hTOFpidNCfromDstar","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistNoCutsFromDstar->Add(hTOFpidNCfromDstar); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptNCfromDstar->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hd0zD0ptNCfromDstar); + + namehist="hInvMassNCfromDstar_pt"; + namehist+=i; + titlehist="Invariant Mass No Cuts FromDstar ptbin="; + titlehist+=i; + hInvMassNCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassNCfromDstar->SetXTitle("Invariant Mass [GeV]"); + hInvMassNCfromDstar->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hInvMassNCfromDstar); + + namehist="hetaNCfromDstar_pt"; + namehist+=i; + titlehist="eta No Cuts FromDstar ptbin="; + titlehist+=i; + hetaNCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaNCfromDstar->SetXTitle("Pseudorapidity"); + hetaNCfromDstar->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hetaNCfromDstar); + + namehist="hCosPDPBNCfromDstar_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBNCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBNCfromDstar->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBNCfromDstar->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hCosPDPBNCfromDstar); + + namehist="hCosPcPDNCfromDstar_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDNCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDNCfromDstar->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDNCfromDstar->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hCosPcPDNCfromDstar); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0NCfromDstar_pt"; + namehist+=i; + titlehist="d0xd0 No Cuts FromDstar ptbin="; + titlehist+=i; + hd0xd0NCfromDstarpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0NCfromDstarpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0NCfromDstarpt->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hd0xd0NCfromDstarpt); + + + namehist="hd0D0VSd0xd0NCfromDstar_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} No Cuts FromDstar ptbin="; + titlehist+=i; + hd0D0VSd0xd0NCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0NCfromDstarpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0NCfromDstarpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistNoCutsFromDstar->Add(hd0D0VSd0xd0NCfromDstarpt); + + + namehist="hangletracksVSd0xd0NCfromDstar_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} No Cuts FromDstar ptbin="; + titlehist+=i; + hangletracksVSd0xd0NCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0NCfromDstarpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0NCfromDstarpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsFromDstar->Add(hangletracksVSd0xd0NCfromDstarpt); + + + namehist="hangletracksVSd0D0NCfromDstar_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} No Cuts FromDstar ptbin="; + titlehist+=i; + hangletracksVSd0D0NCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0NCfromDstarpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0NCfromDstarpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsFromDstar->Add(hangletracksVSd0D0NCfromDstarpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + //########## d0 D0 histos ############# TH1F *hd0D0NCfromDstPM = new TH1F("hd0D0NCfromDstarPM","D^{0} impact par. plot , No Cuts ,FromDStar,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0NCfromDstPM->SetXTitle("Impact parameter [#mum]"); @@ -939,12 +1629,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsFromDstar->Add(hd0D0VtxTrueNCfromDstSB); flistNoCutsFromDstar->Add(hMCd0D0NCfromDstSB); - TH1F **hd0D0ptNCfromDstPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCfromDstPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCfromDstPM=new TH1F*[fnbins]; - TH1F **hd0D0ptNCfromDstSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCfromDstSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCfromDstSB=new TH1F*[fnbins]; + TH1F *hd0D0ptNCfromDstPM; + TH1F *hMCd0D0ptNCfromDstPM; + TH1F *hd0D0VtxTrueptNCfromDstPM; + TH1F *hd0D0ptNCfromDstSB; + TH1F *hMCd0D0ptNCfromDstSB; + TH1F *hd0D0VtxTrueptNCfromDstSB; namehist="hd0D0ptNCfromDstar_"; titlehist="D^{0} impact par. plot, No Cuts, FromDStar, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptNCfromDstPM[i]->SetYTitle("Entries"); - flistNoCutsFromDstar->Add(hd0D0ptNCfromDstPM[i]); + hd0D0ptNCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCfromDstPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCfromDstPM->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hd0D0ptNCfromDstPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCfromDstPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCfromDstPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCfromDstPM[i]->SetYTitle("Entries"); - flistNoCutsFromDstar->Add(hMCd0D0ptNCfromDstPM[i]); + hMCd0D0ptNCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCfromDstPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCfromDstPM->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hMCd0D0ptNCfromDstPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCfromDstPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCfromDstPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCfromDstPM[i]->SetYTitle("Entries"); - flistNoCutsFromDstar->Add(hd0D0VtxTrueptNCfromDstPM[i]); + hd0D0VtxTrueptNCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCfromDstPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCfromDstPM->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hd0D0VtxTrueptNCfromDstPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -988,22 +1678,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptNCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptNCfromDstSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptNCfromDstSB[i]->SetYTitle("Entries"); - flistNoCutsFromDstar->Add(hd0D0ptNCfromDstSB[i]); + hd0D0ptNCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCfromDstSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCfromDstSB->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hd0D0ptNCfromDstSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCfromDstSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCfromDstSB[i]->SetYTitle("Entries"); - flistNoCutsFromDstar->Add(hMCd0D0ptNCfromDstSB[i]); + hMCd0D0ptNCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCfromDstSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCfromDstSB->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hMCd0D0ptNCfromDstSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCfromDstSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCfromDstSB[i]->SetYTitle("Entries"); - flistNoCutsFromDstar->Add(hd0D0VtxTrueptNCfromDstSB[i]); + hd0D0VtxTrueptNCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCfromDstSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCfromDstSB->SetYTitle("Entries"); + flistNoCutsFromDstar->Add(hd0D0VtxTrueptNCfromDstSB); } @@ -1011,13 +1701,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //########### global properties histos ########### - TH2F *hCPtaVSd0d0NCother=new TH2F("hCPtaVSd0d0NCother","hCPtaVSd0d0_NoCuts_other",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0NCother=new TH2F("hCPtaVSd0d0NCother","hCPtaVSd0d0_NoCuts_other",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZNCother=new TH1F("hSecVtxZNCother","hSecVtxZ_NoCuts_other",1000,-8.,8.); TH1F *hSecVtxXNCother=new TH1F("hSecVtxXNCother","hSecVtxX_NoCuts_other",1000,-3000.,3000.); TH1F *hSecVtxYNCother=new TH1F("hSecVtxYNCother","hSecVtxY_NoCuts_other",1000,-3000.,3000.); TH2F *hSecVtxXYNCother=new TH2F("hSecVtxXYNCother","hSecVtxXY_NoCuts_other",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiNCother=new TH1F("hSecVtxPhiNCother","hSecVtxPhi_NoCuts_other",180,-180.1,180.1); - TH1F *hCPtaNCother=new TH1F("hCPtaNCother","hCPta_NoCuts_other",100,0.,1.); + TH1F *hd0singlTrackNCother=new TH1F("hd0singlTrackNCother","hd0singlTrackNoCuts_Other",1000,-5000.,5000.); + TH1F *hCPtaNCother=new TH1F("hCPtaNCother","hCPta_NoCuts_other",100,-1.,1.); TH1F *hd0xd0NCother=new TH1F("hd0xd0NCother","hd0xd0_NoCuts_other",1000,-100000.,100000.); TH1F *hMassTrueNCother=new TH1F("hMassTrueNCother","D^{0} MC inv. Mass No Cuts other(All momenta)",600,1.600,2.200); TH1F *hMassNCother=new TH1F("hMassNCother","D^{0} inv. Mass No Cuts other (All momenta)",600,1.600,2.200); @@ -1035,6 +1726,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsOther->Add(hSecVtxXNCother); flistNoCutsOther->Add(hSecVtxXYNCother); flistNoCutsOther->Add(hSecVtxPhiNCother); + flistNoCutsOther->Add(hd0singlTrackNCother); flistNoCutsOther->Add(hCPtaNCother); flistNoCutsOther->Add(hd0xd0NCother); flistNoCutsOther->Add(hMassTrueNCother); @@ -1044,6 +1736,146 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsOther->Add(hMassTrueNCotherSB); flistNoCutsOther->Add(hMassNCotherSB); + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaNCother=new TH1F("hdcaNCother","hdca_NoCuts_Other",100,0.,1000.); + hdcaNCother->SetXTitle("dca [#mum]"); + hdcaNCother->SetYTitle("Entries"); + TH1F *hcosthetastarNCother=new TH1F("hcosthetastarNCother","hCosThetaStar_NoCuts_Other",50,-1.,1.); + hcosthetastarNCother->SetXTitle("cos #theta^{*}"); + hcosthetastarNCother->SetYTitle("Entries"); + TH1F *hptD0NCother=new TH1F("hptD0NCother","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0NCother->SetXTitle("p_{t} [GeV/c]"); + hptD0NCother->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtNCother=new TH1F("hptD0VsMaxPtNCother","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtNCother=new TH2F("hptD0PTallsqrtNCother","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallNCother=new TH2F("hptD0PTallNCother","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBNCother=new TH2F("hptD0vsptBNCother","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBNCother=new TH2F("hpD0vspBNCother","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkNCother=new TH2F("hptD0vsptcquarkNCother","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkNCother=new TH2F("hpD0vspcquarkNCother","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistNoCutsOther->Add(hdcaNCother); + flistNoCutsOther->Add(hcosthetastarNCother); + flistNoCutsOther->Add(hptD0NCother); + flistNoCutsOther->Add(hptD0VsMaxPtNCother); + flistNoCutsOther->Add(hptD0PTallsqrtNCother); + flistNoCutsOther->Add(hptD0PTallNCother); + flistNoCutsOther->Add(hptD0vsptBNCother); + flistNoCutsOther->Add(hpD0vspBNCother); + flistNoCutsOther->Add(hptD0vsptcquarkNCother); + flistNoCutsOther->Add(hpD0vspcquarkNCother); + + TH1F *hd0zD0ptNCother; + TH1F *hInvMassNCother; + TH2F *hInvMassPtNCother=new TH2F("hInvMassPtNCother","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaNCother; + TH1F *hCosPDPBNCother; + TH1F *hCosPcPDNCother; + flistNoCutsOther->Add(hInvMassPtNCother); + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0NCotherpt; + TH2F *hangletracksVSd0xd0NCotherpt; + TH2F *hangletracksVSd0D0NCotherpt; + TH1F *hd0xd0NCotherpt; + + TH2F *hTOFpidNCother=new TH2F("hTOFpidNCother","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistNoCutsOther->Add(hTOFpidNCother); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptNCother->SetYTitle("Entries"); + flistNoCutsOther->Add(hd0zD0ptNCother); + + namehist="hInvMassNCother_pt"; + namehist+=i; + titlehist="Invariant Mass No Cuts Other ptbin="; + titlehist+=i; + hInvMassNCother=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassNCother->SetXTitle("Invariant Mass [GeV]"); + hInvMassNCother->SetYTitle("Entries"); + flistNoCutsOther->Add(hInvMassNCother); + + namehist="hetaNCother_pt"; + namehist+=i; + titlehist="eta No Cuts Other ptbin="; + titlehist+=i; + hetaNCother=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaNCother->SetXTitle("Pseudorapidity"); + hetaNCother->SetYTitle("Entries"); + flistNoCutsOther->Add(hetaNCother); + + namehist="hCosPDPBNCother_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBNCother=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBNCother->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBNCother->SetYTitle("Entries"); + flistNoCutsOther->Add(hCosPDPBNCother); + + namehist="hCosPcPDNCother_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDNCother=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDNCother->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDNCother->SetYTitle("Entries"); + flistNoCutsOther->Add(hCosPcPDNCother); + + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0NCother_pt"; + namehist+=i; + titlehist="d0xd0 No Cuts Other ptbin="; + titlehist+=i; + hd0xd0NCotherpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0NCotherpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0NCotherpt->SetYTitle("Entries"); + flistNoCutsOther->Add(hd0xd0NCotherpt); + + + namehist="hd0D0VSd0xd0NCother_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} No Cuts Other ptbin="; + titlehist+=i; + hd0D0VSd0xd0NCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0NCotherpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0NCotherpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistNoCutsOther->Add(hd0D0VSd0xd0NCotherpt); + + + namehist="hangletracksVSd0xd0NCother_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} No Cuts Other ptbin="; + titlehist+=i; + hangletracksVSd0xd0NCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0NCotherpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0NCotherpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsOther->Add(hangletracksVSd0xd0NCotherpt); + + + namehist="hangletracksVSd0D0NCother_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} No Cuts Other ptbin="; + titlehist+=i; + hangletracksVSd0D0NCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0NCotherpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0NCotherpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistNoCutsOther->Add(hangletracksVSd0D0NCotherpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + //############# d0 D0 histos ###############à TH1F *hd0D0NCotherPM = new TH1F("hd0D0NCotherPM","D^{0} impact par. plot , No Cuts ,Other,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0NCotherPM->SetXTitle("Impact parameter [#mum]"); @@ -1076,12 +1908,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistNoCutsOther->Add(hd0D0VtxTrueNCotherSB); flistNoCutsOther->Add(hMCd0D0NCotherSB); - TH1F **hd0D0ptNCotherPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCotherPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCotherPM=new TH1F*[fnbins]; - TH1F **hd0D0ptNCotherSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptNCotherSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptNCotherSB=new TH1F*[fnbins]; + TH1F *hd0D0ptNCotherPM; + TH1F *hMCd0D0ptNCotherPM; + TH1F *hd0D0VtxTrueptNCotherPM; + TH1F *hd0D0ptNCotherSB; + TH1F *hMCd0D0ptNCotherSB; + TH1F *hd0D0VtxTrueptNCotherSB; namehist="hd0D0ptNCother_"; titlehist="D^{0} impact par. plot, No Cuts, Other, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptNCotherPM[i]->SetYTitle("Entries"); - flistNoCutsOther->Add(hd0D0ptNCotherPM[i]); + hd0D0ptNCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCotherPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCotherPM->SetYTitle("Entries"); + flistNoCutsOther->Add(hd0D0ptNCotherPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCotherPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCotherPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCotherPM[i]->SetYTitle("Entries"); - flistNoCutsOther->Add(hMCd0D0ptNCotherPM[i]); + hMCd0D0ptNCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCotherPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCotherPM->SetYTitle("Entries"); + flistNoCutsOther->Add(hMCd0D0ptNCotherPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCotherPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCotherPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCotherPM[i]->SetYTitle("Entries"); - flistNoCutsOther->Add(hd0D0VtxTrueptNCotherPM[i]); + hd0D0VtxTrueptNCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCotherPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCotherPM->SetYTitle("Entries"); + flistNoCutsOther->Add(hd0D0VtxTrueptNCotherPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1125,22 +1957,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptNCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptNCotherSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptNCotherSB[i]->SetYTitle("Entries"); - flistNoCutsOther->Add(hd0D0ptNCotherSB[i]); + hd0D0ptNCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptNCotherSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptNCotherSB->SetYTitle("Entries"); + flistNoCutsOther->Add(hd0D0ptNCotherSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptNCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptNCotherSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptNCotherSB[i]->SetYTitle("Entries"); - flistNoCutsOther->Add(hMCd0D0ptNCotherSB[i]); + hMCd0D0ptNCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptNCotherSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptNCotherSB->SetYTitle("Entries"); + flistNoCutsOther->Add(hMCd0D0ptNCotherSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptNCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptNCotherSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptNCotherSB[i]->SetYTitle("Entries"); - flistNoCutsOther->Add(hd0D0VtxTrueptNCotherSB[i]); + hd0D0VtxTrueptNCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptNCotherSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptNCotherSB->SetYTitle("Entries"); + flistNoCutsOther->Add(hd0D0VtxTrueptNCotherSB); } @@ -1154,13 +1986,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // // ####### global properties histo ############ - TH2F *hCPtaVSd0d0LSCsign=new TH2F("hCPtaVSd0d0LSCsign","hCPtaVSd0d0_LooseCuts_Signal",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0LSCsign=new TH2F("hCPtaVSd0d0LSCsign","hCPtaVSd0d0_LooseCuts_Signal",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZLSCsign=new TH1F("hSecVtxZLSCsign","hSecVtxZ_LooseCuts_Signal",1000,-8.,8.); TH1F *hSecVtxXLSCsign=new TH1F("hSecVtxXLSCsign","hSecVtxX_LooseCuts_Signal",1000,-3000.,3000.); TH1F *hSecVtxYLSCsign=new TH1F("hSecVtxYLSCsign","hSecVtxY_LooseCuts_Signal",1000,-3000.,3000.); TH2F *hSecVtxXYLSCsign=new TH2F("hSecVtxXYLSCsign","hSecVtxXY_LooseCuts_Signal",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiLSCsign=new TH1F("hSecVtxPhiLSCsign","hSecVtxPhi_LooseCuts_Signal",180,-180.1,180.1); - TH1F *hCPtaLSCsign=new TH1F("hCPtaLSCsign","hCPta_LooseCuts_Signal",100,0.,1.); + TH1F *hd0singlTrackLSCsign=new TH1F("hd0singlTrackLSCsign","hd0singlTrackLooseCuts_Signal",1000,-5000.,5000.); + TH1F *hCPtaLSCsign=new TH1F("hCPtaLSCsign","hCPta_LooseCuts_Signal",100,-1.,1.); TH1F *hd0xd0LSCsign=new TH1F("hd0xd0LSCsign","hd0xd0_LooseCuts_Signal",1000,-100000.,100000.); TH1F *hMassTrueLSCsign=new TH1F("hMassTrueLSCsign","D^{0} MC inv. Mass Loose Cuts Signal(All momenta)",600,1.600,2.200); TH1F *hMassLSCsign=new TH1F("hMassLSCsign","D^{0} inv. Mass Loose Cuts Signal (All momenta)",600,1.600,2.200); @@ -1178,6 +2011,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsSignal->Add(hSecVtxXLSCsign); flistLsCutsSignal->Add(hSecVtxXYLSCsign); flistLsCutsSignal->Add(hSecVtxPhiLSCsign); + flistLsCutsSignal->Add(hd0singlTrackLSCsign); flistLsCutsSignal->Add(hCPtaLSCsign); flistLsCutsSignal->Add(hd0xd0LSCsign); flistLsCutsSignal->Add(hMassTrueLSCsign); @@ -1187,6 +2021,145 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsSignal->Add(hMassTrueLSCsignSB); flistLsCutsSignal->Add(hMassLSCsignSB); + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaLSCsign=new TH1F("hdcaLSCsign","hdca_LooseCuts_Sign",100,0.,1000.); + hdcaLSCsign->SetXTitle("dca [#mum]"); + hdcaLSCsign->SetYTitle("Entries"); + TH1F *hcosthetastarLSCsign=new TH1F("hcosthetastarLSCsign","hCosThetaStar_LooseCuts_Sign",50,-1.,1.); + hcosthetastarLSCsign->SetXTitle("cos #theta^{*}"); + hcosthetastarLSCsign->SetYTitle("Entries"); + TH1F *hptD0LSCsign=new TH1F("hptD0LSCsign","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0LSCsign->SetXTitle("p_{t} [GeV/c]"); + hptD0LSCsign->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtLSCsign=new TH1F("hptD0VsMaxPtLSCsign","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtLSCsign=new TH2F("hptD0PTallsqrtLSCsign","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallLSCsign=new TH2F("hptD0PTallLSCsign","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBLSCsign=new TH2F("hptD0vsptBLSCsign","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBLSCsign=new TH2F("hpD0vspBLSCsign","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkLSCsign=new TH2F("hptD0vsptcquarkLSCsign","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkLSCsign=new TH2F("hpD0vspcquarkLSCsign","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistLsCutsSignal->Add(hdcaLSCsign); + flistLsCutsSignal->Add(hcosthetastarLSCsign); + flistLsCutsSignal->Add(hptD0LSCsign); + flistLsCutsSignal->Add(hptD0VsMaxPtLSCsign); + flistLsCutsSignal->Add(hptD0PTallsqrtLSCsign); + flistLsCutsSignal->Add(hptD0PTallLSCsign); + flistLsCutsSignal->Add(hptD0vsptBLSCsign); + flistLsCutsSignal->Add(hpD0vspBLSCsign); + flistLsCutsSignal->Add(hptD0vsptcquarkLSCsign); + flistLsCutsSignal->Add(hpD0vspcquarkLSCsign); + + TH1F *hd0zD0ptLSCsign; + TH1F *hInvMassLSCsign; + TH2F *hInvMassPtLSCsign=new TH2F("hInvMassPtLSCsign","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaLSCsign; + TH1F *hCosPDPBLSCsign; + TH1F *hCosPcPDLSCsign; + flistLsCutsSignal->Add(hInvMassPtLSCsign); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0LSCsignpt; + TH2F *hangletracksVSd0xd0LSCsignpt; + TH2F *hangletracksVSd0D0LSCsignpt; + TH1F *hd0xd0LSCsignpt; + + TH2F *hTOFpidLSCsign=new TH2F("hTOFpidLSCsign","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistLsCutsSignal->Add(hTOFpidLSCsign); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptLSCsign->SetYTitle("Entries"); + flistLsCutsSignal->Add(hd0zD0ptLSCsign); + + namehist="hInvMassLSCsign_pt"; + namehist+=i; + titlehist="Invariant Mass Loose Cuts Sign ptbin="; + titlehist+=i; + hInvMassLSCsign=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassLSCsign->SetXTitle("Invariant Mass [GeV]"); + hInvMassLSCsign->SetYTitle("Entries"); + flistLsCutsSignal->Add(hInvMassLSCsign); + + namehist="hetaLSCsign_pt"; + namehist+=i; + titlehist="eta Loose Cuts Sign ptbin="; + titlehist+=i; + hetaLSCsign=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaLSCsign->SetXTitle("Pseudorapidity"); + hetaLSCsign->SetYTitle("Entries"); + flistLsCutsSignal->Add(hetaLSCsign); + + namehist="hCosPDPBLSCsign_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBLSCsign=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBLSCsign->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBLSCsign->SetYTitle("Entries"); + flistLsCutsSignal->Add(hCosPDPBLSCsign); + + namehist="hCosPcPDLSCsign_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDLSCsign=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDLSCsign->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDLSCsign->SetYTitle("Entries"); + flistLsCutsSignal->Add(hCosPcPDLSCsign); + + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0LSCsign_pt"; + namehist+=i; + titlehist="d0xd0 Loose Cuts Sign ptbin="; + titlehist+=i; + hd0xd0LSCsignpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0LSCsignpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0LSCsignpt->SetYTitle("Entries"); + flistLsCutsSignal->Add(hd0xd0LSCsignpt); + + + namehist="hd0D0VSd0xd0LSCsign_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts Sign ptbin="; + titlehist+=i; + hd0D0VSd0xd0LSCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0LSCsignpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0LSCsignpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistLsCutsSignal->Add(hd0D0VSd0xd0LSCsignpt); + + + namehist="hangletracksVSd0xd0LSCsign_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts Sign ptbin="; + titlehist+=i; + hangletracksVSd0xd0LSCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0LSCsignpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0LSCsignpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsSignal->Add(hangletracksVSd0xd0LSCsignpt); + + + namehist="hangletracksVSd0D0LSCsign_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Loose Cuts Sign ptbin="; + titlehist+=i; + hangletracksVSd0D0LSCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0LSCsignpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0LSCsignpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsSignal->Add(hangletracksVSd0D0LSCsignpt); + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + // ####### d0 D0 histos ############ TH1F *hd0D0LSCsignPM = new TH1F("hd0D0LSCsignPM","D^{0} impact par. plot , Loose Cuts ,Signal,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0LSCsignPM->SetXTitle("Impact parameter [#mum]"); @@ -1219,12 +2192,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsSignal->Add(hd0D0VtxTrueLSCsignSB); flistLsCutsSignal->Add(hMCd0D0LSCsignSB); - TH1F **hd0D0ptLSCsignPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCsignPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCsignPM=new TH1F*[fnbins]; - TH1F **hd0D0ptLSCsignSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCsignSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCsignSB=new TH1F*[fnbins]; + TH1F *hd0D0ptLSCsignPM; + TH1F *hMCd0D0ptLSCsignPM; + TH1F *hd0D0VtxTrueptLSCsignPM; + TH1F *hd0D0ptLSCsignSB; + TH1F *hMCd0D0ptLSCsignSB; + TH1F *hd0D0VtxTrueptLSCsignSB; namehist="hd0D0ptLSCsign_"; titlehist="D^{0} impact par. plot, Loose Cuts, Signal, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCsignPM[i]->SetYTitle("Entries"); - flistLsCutsSignal->Add(hd0D0ptLSCsignPM[i]); + hd0D0ptLSCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCsignPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCsignPM->SetYTitle("Entries"); + flistLsCutsSignal->Add(hd0D0ptLSCsignPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCsignPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCsignPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCsignPM[i]->SetYTitle("Entries"); - flistLsCutsSignal->Add(hMCd0D0ptLSCsignPM[i]); + hMCd0D0ptLSCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCsignPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCsignPM->SetYTitle("Entries"); + flistLsCutsSignal->Add(hMCd0D0ptLSCsignPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCsignPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCsignPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCsignPM[i]->SetYTitle("Entries"); - flistLsCutsSignal->Add(hd0D0VtxTrueptLSCsignPM[i]); + hd0D0VtxTrueptLSCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCsignPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCsignPM->SetYTitle("Entries"); + flistLsCutsSignal->Add(hd0D0VtxTrueptLSCsignPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1268,35 +2241,36 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptLSCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptLSCsignSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCsignSB[i]->SetYTitle("Entries"); - flistLsCutsSignal->Add(hd0D0ptLSCsignSB[i]); + hd0D0ptLSCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCsignSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCsignSB->SetYTitle("Entries"); + flistLsCutsSignal->Add(hd0D0ptLSCsignSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCsignSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCsignSB[i]->SetYTitle("Entries"); - flistLsCutsSignal->Add(hMCd0D0ptLSCsignSB[i]); + hMCd0D0ptLSCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCsignSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCsignSB->SetYTitle("Entries"); + flistLsCutsSignal->Add(hMCd0D0ptLSCsignSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCsignSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCsignSB[i]->SetYTitle("Entries"); - flistLsCutsSignal->Add(hd0D0VtxTrueptLSCsignSB[i]); + hd0D0VtxTrueptLSCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCsignSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCsignSB->SetYTitle("Entries"); + flistLsCutsSignal->Add(hd0D0VtxTrueptLSCsignSB); } //############ LOOSE CUTS BACKGROUND HISTOGRAMS ########### // // ######## global properties histos ####### - TH2F *hCPtaVSd0d0LSCback=new TH2F("hCPtaVSd0d0LSCback","hCPtaVSd0d0_LooseCuts_Background",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0LSCback=new TH2F("hCPtaVSd0d0LSCback","hCPtaVSd0d0_LooseCuts_Background",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZLSCback=new TH1F("hSecVtxZLSCback","hSecVtxZ_LooseCuts_Background",1000,-8.,8.); TH1F *hSecVtxXLSCback=new TH1F("hSecVtxXLSCback","hSecVtxX_LooseCuts_Background",1000,-3000.,3000.); TH1F *hSecVtxYLSCback=new TH1F("hSecVtxYLSCback","hSecVtxY_LooseCuts_Background",1000,-3000.,3000.); TH2F *hSecVtxXYLSCback=new TH2F("hSecVtxXYLSCback","hSecVtxXY_LooseCuts_Background",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiLSCback=new TH1F("hSecVtxPhiLSCback","hSecVtxPhi_LooseCuts_Background",180,-180.1,180.1); - TH1F *hCPtaLSCback=new TH1F("hCPtaLSCback","hCPta_LooseCuts_Background",100,0.,1.); + TH1F *hd0singlTrackLSCback=new TH1F("hd0singlTrackLSCback","hd0singlTrackLooseCuts_Back",1000,-5000.,5000.); + TH1F *hCPtaLSCback=new TH1F("hCPtaLSCback","hCPta_LooseCuts_Background",100,-1.,1.); TH1F *hd0xd0LSCback=new TH1F("hd0xd0LSCback","hd0xd0_LooseCuts_Background",1000,-100000.,100000.); TH1F *hMassTrueLSCback=new TH1F("hMassTrueLSCback","D^{0} MC inv. Mass Loose Cuts Background(All momenta)",600,1.600,2.200); TH1F *hMassLSCback=new TH1F("hMassLSCback","D^{0} inv. Mass Loose Cuts Background (All momenta)",600,1.600,2.200); @@ -1314,6 +2288,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsBack->Add(hSecVtxXLSCback); flistLsCutsBack->Add(hSecVtxXYLSCback); flistLsCutsBack->Add(hSecVtxPhiLSCback); + flistLsCutsBack->Add(hd0singlTrackLSCback); flistLsCutsBack->Add(hCPtaLSCback); flistLsCutsBack->Add(hd0xd0LSCback); flistLsCutsBack->Add(hMassTrueLSCback); @@ -1324,6 +2299,152 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsBack->Add(hMassLSCbackSB); + + + + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaLSCback=new TH1F("hdcaLSCback","hdca_LooseCuts_Backgr",100,0.,1000.); + hdcaLSCback->SetXTitle("dca [#mum]"); + hdcaLSCback->SetYTitle("Entries"); + TH1F *hcosthetastarLSCback=new TH1F("hcosthetastarLSCback","hCosThetaStar_LooseCuts_Backgr",50,-1.,1.); + hcosthetastarLSCback->SetXTitle("cos #theta^{*}"); + hcosthetastarLSCback->SetYTitle("Entries"); + TH1F *hptD0LSCback=new TH1F("hptD0LSCback","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0LSCback->SetXTitle("p_{t} [GeV/c]"); + hptD0LSCback->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtLSCback=new TH1F("hptD0VsMaxPtLSCback","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtLSCback=new TH2F("hptD0PTallsqrtLSCback","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallLSCback=new TH2F("hptD0PTallLSCback","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBLSCback=new TH2F("hptD0vsptBLSCback","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBLSCback=new TH2F("hpD0vspBLSCback","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkLSCback=new TH2F("hptD0vsptcquarkLSCback","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkLSCback=new TH2F("hpD0vspcquarkLSCback","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistLsCutsBack->Add(hdcaLSCback); + flistLsCutsBack->Add(hcosthetastarLSCback); + flistLsCutsBack->Add(hptD0LSCback); + flistLsCutsBack->Add(hptD0VsMaxPtLSCback); + flistLsCutsBack->Add(hptD0PTallsqrtLSCback); + flistLsCutsBack->Add(hptD0PTallLSCback); + flistLsCutsBack->Add(hptD0vsptBLSCback); + flistLsCutsBack->Add(hpD0vspBLSCback); + flistLsCutsBack->Add(hptD0vsptcquarkLSCback); + flistLsCutsBack->Add(hpD0vspcquarkLSCback); + + TH1F *hd0zD0ptLSCback; + TH1F *hInvMassLSCback; + TH2F *hInvMassPtLSCback=new TH2F("hInvMassPtLSCback","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaLSCback; + TH1F *hCosPDPBLSCback; + TH1F *hCosPcPDLSCback; + flistLsCutsBack->Add(hInvMassPtLSCback); + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0LSCbackpt; + TH2F *hangletracksVSd0xd0LSCbackpt; + TH2F *hangletracksVSd0D0LSCbackpt; + TH1F *hd0xd0LSCbackpt; + + TH2F *hTOFpidLSCback=new TH2F("hTOFpidLSCback","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistLsCutsBack->Add(hTOFpidLSCback); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptLSCback->SetYTitle("Entries"); + flistLsCutsBack->Add(hd0zD0ptLSCback); + + namehist="hInvMassLSCback_pt"; + namehist+=i; + titlehist="Invariant Mass Loose Cuts Backgr ptbin="; + titlehist+=i; + hInvMassLSCback=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassLSCback->SetXTitle("Invariant Mass [GeV]"); + hInvMassLSCback->SetYTitle("Entries"); + flistLsCutsBack->Add(hInvMassLSCback); + + namehist="hetaLSCback_pt"; + namehist+=i; + titlehist="eta Loose Cuts Backgr ptbin="; + titlehist+=i; + hetaLSCback=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaLSCback->SetXTitle("Pseudorapidity"); + hetaLSCback->SetYTitle("Entries"); + flistLsCutsBack->Add(hetaLSCback); + + namehist="hCosPDPBLSCback_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBLSCback=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBLSCback->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBLSCback->SetYTitle("Entries"); + flistLsCutsBack->Add(hCosPDPBLSCback); + + namehist="hCosPcPDLSCback_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDLSCback=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDLSCback->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDLSCback->SetYTitle("Entries"); + flistLsCutsBack->Add(hCosPcPDLSCback); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0LSCback_pt"; + namehist+=i; + titlehist="d0xd0 Loose Cuts Back ptbin="; + titlehist+=i; + hd0xd0LSCbackpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0LSCbackpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0LSCbackpt->SetYTitle("Entries"); + flistLsCutsBack->Add(hd0xd0LSCbackpt); + + + namehist="hd0D0VSd0xd0LSCback_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts Back ptbin="; + titlehist+=i; + hd0D0VSd0xd0LSCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0LSCbackpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0LSCbackpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistLsCutsBack->Add(hd0D0VSd0xd0LSCbackpt); + + + namehist="hangletracksVSd0xd0LSCback_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts Back ptbin="; + titlehist+=i; + hangletracksVSd0xd0LSCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0LSCbackpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0LSCbackpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsBack->Add(hangletracksVSd0xd0LSCbackpt); + + + namehist="hangletracksVSd0D0LSCback_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Loose Cuts Back ptbin="; + titlehist+=i; + hangletracksVSd0D0LSCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0LSCbackpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0LSCbackpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsBack->Add(hangletracksVSd0D0LSCbackpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + + + // ####### d0 D0 histos ############ TH1F *hd0D0LSCbackPM = new TH1F("hd0D0LSCbackPM","D^{0} impact par. plot , Loose Cuts ,Background,Mass Peak (All momenta)",1000,-1000.,1000.); @@ -1357,12 +2478,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsBack->Add(hd0D0VtxTrueLSCbackSB); flistLsCutsBack->Add(hMCd0D0LSCbackSB); - TH1F **hd0D0ptLSCbackPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCbackPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCbackPM=new TH1F*[fnbins]; - TH1F **hd0D0ptLSCbackSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCbackSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCbackSB=new TH1F*[fnbins]; + TH1F *hd0D0ptLSCbackPM; + TH1F *hMCd0D0ptLSCbackPM; + TH1F *hd0D0VtxTrueptLSCbackPM; + TH1F *hd0D0ptLSCbackSB; + TH1F *hMCd0D0ptLSCbackSB; + TH1F *hd0D0VtxTrueptLSCbackSB; namehist="hd0D0ptLSCback_"; titlehist="D^{0} impact par. plot, Loose Cuts, Background, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCbackPM[i]->SetYTitle("Entries"); - flistLsCutsBack->Add(hd0D0ptLSCbackPM[i]); + hd0D0ptLSCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCbackPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCbackPM->SetYTitle("Entries"); + flistLsCutsBack->Add(hd0D0ptLSCbackPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCbackPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCbackPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCbackPM[i]->SetYTitle("Entries"); - flistLsCutsBack->Add(hMCd0D0ptLSCbackPM[i]); + hMCd0D0ptLSCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCbackPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCbackPM->SetYTitle("Entries"); + flistLsCutsBack->Add(hMCd0D0ptLSCbackPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCbackPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCbackPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCbackPM[i]->SetYTitle("Entries"); - flistLsCutsBack->Add(hd0D0VtxTrueptLSCbackPM[i]); + hd0D0VtxTrueptLSCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCbackPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCbackPM->SetYTitle("Entries"); + flistLsCutsBack->Add(hd0D0VtxTrueptLSCbackPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1406,22 +2527,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptLSCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptLSCbackSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCbackSB[i]->SetYTitle("Entries"); - flistLsCutsBack->Add(hd0D0ptLSCbackSB[i]); + hd0D0ptLSCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCbackSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCbackSB->SetYTitle("Entries"); + flistLsCutsBack->Add(hd0D0ptLSCbackSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCbackSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCbackSB[i]->SetYTitle("Entries"); - flistLsCutsBack->Add(hMCd0D0ptLSCbackSB[i]); + hMCd0D0ptLSCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCbackSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCbackSB->SetYTitle("Entries"); + flistLsCutsBack->Add(hMCd0D0ptLSCbackSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCbackSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCbackSB[i]->SetYTitle("Entries"); - flistLsCutsBack->Add(hd0D0VtxTrueptLSCbackSB[i]); + hd0D0VtxTrueptLSCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCbackSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCbackSB->SetYTitle("Entries"); + flistLsCutsBack->Add(hd0D0VtxTrueptLSCbackSB); } @@ -1430,13 +2551,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //####### global properties histos - TH2F *hCPtaVSd0d0LSCfromB=new TH2F("hCPtaVSd0d0LSCfromB","hCPtaVSd0d0_LooseCuts_FromB",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0LSCfromB=new TH2F("hCPtaVSd0d0LSCfromB","hCPtaVSd0d0_LooseCuts_FromB",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZLSCfromB=new TH1F("hSecVtxZLSCfromB","hSecVtxZ_LooseCuts_FromB",1000,-8.,8.); TH1F *hSecVtxXLSCfromB=new TH1F("hSecVtxXLSCfromB","hSecVtxX_LooseCuts_FromB",1000,-3000.,3000.); TH1F *hSecVtxYLSCfromB=new TH1F("hSecVtxYLSCfromB","hSecVtxY_LooseCuts_FromB",1000,-3000.,3000.); TH2F *hSecVtxXYLSCfromB=new TH2F("hSecVtxXYLSCfromB","hSecVtxXY_LooseCuts_FromB",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiLSCfromB=new TH1F("hSecVtxPhiLSCfromB","hSecVtxPhi_LooseCuts_FromB",180,-180.1,180.1); - TH1F *hCPtaLSCfromB=new TH1F("hCPtaLSCfromB","hCPta_LooseCuts_FromB",100,0.,1.); + TH1F *hd0singlTrackLSCfromB=new TH1F("hd0singlTrackLSCfromB","hd0singlTrackLooseCuts_FromB",1000,-5000.,5000.); + TH1F *hCPtaLSCfromB=new TH1F("hCPtaLSCfromB","hCPta_LooseCuts_FromB",100,-1.,1.); TH1F *hd0xd0LSCfromB=new TH1F("hd0xd0LSCfromB","hd0xd0_LooseCuts_FromB",1000,-100000.,100000.); TH1F *hMassTrueLSCfromB=new TH1F("hMassTrueLSCfromB","D^{0} MC inv. Mass Loose Cuts FromB(All momenta)",600,1.600,2.200); TH1F *hMassLSCfromB=new TH1F("hMassLSCfromB","D^{0} inv. Mass Loose Cuts FromB (All momenta)",600,1.600,2.200); @@ -1454,6 +2576,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsFromB->Add(hSecVtxXLSCfromB); flistLsCutsFromB->Add(hSecVtxXYLSCfromB); flistLsCutsFromB->Add(hSecVtxPhiLSCfromB); + flistLsCutsFromB->Add(hd0singlTrackLSCfromB); flistLsCutsFromB->Add(hCPtaLSCfromB); flistLsCutsFromB->Add(hd0xd0LSCfromB); flistLsCutsFromB->Add(hMassTrueLSCfromB); @@ -1463,6 +2586,148 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsFromB->Add(hMassTrueLSCfromBSB); flistLsCutsFromB->Add(hMassLSCfromBSB); + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaLSCfromB=new TH1F("hdcaLSCfromB","hdca_LooseCuts_FromB",100,0.,1000.); + hdcaLSCfromB->SetXTitle("dca [#mum]"); + hdcaLSCfromB->SetYTitle("Entries"); + TH1F *hcosthetastarLSCfromB=new TH1F("hcosthetastarLSCfromB","hCosThetaStar_LooseCuts_FromB",50,-1.,1.); + hcosthetastarLSCfromB->SetXTitle("cos #theta^{*}"); + hcosthetastarLSCfromB->SetYTitle("Entries"); + TH1F *hptD0LSCfromB=new TH1F("hptD0LSCfromB","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0LSCfromB->SetXTitle("p_{t} [GeV/c]"); + hptD0LSCfromB->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtLSCfromB=new TH1F("hptD0VsMaxPtLSCfromB","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtLSCfromB=new TH2F("hptD0PTallsqrtLSCfromB","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallLSCfromB=new TH2F("hptD0PTallLSCfromB","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBLSCfromB=new TH2F("hptD0vsptBLSCfromB","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBLSCfromB=new TH2F("hpD0vspBLSCfromB","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkLSCfromB=new TH2F("hptD0vsptcquarkLSCfromB","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkLSCfromB=new TH2F("hpD0vspcquarkLSCfromB","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistLsCutsFromB->Add(hdcaLSCfromB); + flistLsCutsFromB->Add(hcosthetastarLSCfromB); + flistLsCutsFromB->Add(hptD0LSCfromB); + flistLsCutsFromB->Add(hptD0VsMaxPtLSCfromB); + flistLsCutsFromB->Add(hptD0PTallsqrtLSCfromB); + flistLsCutsFromB->Add(hptD0PTallLSCfromB); + flistLsCutsFromB->Add(hptD0vsptBLSCfromB); + flistLsCutsFromB->Add(hpD0vspBLSCfromB); + flistLsCutsFromB->Add(hptD0vsptcquarkLSCfromB); + flistLsCutsFromB->Add(hpD0vspcquarkLSCfromB); + + TH1F *hd0zD0ptLSCfromB; + TH1F *hInvMassLSCfromB; + TH2F *hInvMassPtLSCfromB=new TH2F("hInvMassPtLSCfromB","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaLSCfromB; + TH1F *hCosPDPBLSCfromB; + TH1F *hCosPcPDLSCfromB; + flistLsCutsFromB->Add(hInvMassPtLSCfromB); + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0LSCfromBpt; + TH2F *hangletracksVSd0xd0LSCfromBpt; + TH2F *hangletracksVSd0D0LSCfromBpt; + TH1F *hd0xd0LSCfromBpt; + + + TH2F *hTOFpidLSCfromB=new TH2F("hTOFpidLSCfromB","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistLsCutsFromB->Add(hTOFpidLSCfromB); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptLSCfromB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hd0zD0ptLSCfromB); + + namehist="hInvMassLSCfromB_pt"; + namehist+=i; + titlehist="Invariant Mass Loose Cuts FromB ptbin="; + titlehist+=i; + hInvMassLSCfromB=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassLSCfromB->SetXTitle("Invariant Mass [GeV]"); + hInvMassLSCfromB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hInvMassLSCfromB); + + namehist="hetaLSCfromB_pt"; + namehist+=i; + titlehist="eta Loose Cuts FromB ptbin="; + titlehist+=i; + hetaLSCfromB=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaLSCfromB->SetXTitle("Pseudorapidity"); + hetaLSCfromB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hetaLSCfromB); + + namehist="hCosPDPBLSCfromB_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBLSCfromB=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBLSCfromB->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBLSCfromB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hCosPDPBLSCfromB); + + namehist="hCosPcPDLSCfromB_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDLSCfromB=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDLSCfromB->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDLSCfromB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hCosPcPDLSCfromB); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0LSCfromB_pt"; + namehist+=i; + titlehist="d0xd0 Loose Cuts FromB ptbin="; + titlehist+=i; + hd0xd0LSCfromBpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0LSCfromBpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0LSCfromBpt->SetYTitle("Entries"); + flistLsCutsFromB->Add(hd0xd0LSCfromBpt); + + + namehist="hd0D0VSd0xd0LSCfromB_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts FromB ptbin="; + titlehist+=i; + hd0D0VSd0xd0LSCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0LSCfromBpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0LSCfromBpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistLsCutsFromB->Add(hd0D0VSd0xd0LSCfromBpt); + + + namehist="hangletracksVSd0xd0LSCfromB_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts FromB ptbin="; + titlehist+=i; + hangletracksVSd0xd0LSCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0LSCfromBpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0LSCfromBpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsFromB->Add(hangletracksVSd0xd0LSCfromBpt); + + + namehist="hangletracksVSd0D0LSCfromB_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Loose Cuts FromB ptbin="; + titlehist+=i; + hangletracksVSd0D0LSCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0LSCfromBpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0LSCfromBpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsFromB->Add(hangletracksVSd0D0LSCfromBpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + // ######### d0 D0 histos ############## TH1F *hd0D0LSCfromBPM = new TH1F("hd0D0LSCfromBPM","D^{0} impact par. plot , Loose Cuts ,FromB,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0LSCfromBPM->SetXTitle("Impact parameter [#mum]"); @@ -1495,12 +2760,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsFromB->Add(hd0D0VtxTrueLSCfromBSB); flistLsCutsFromB->Add(hMCd0D0LSCfromBSB); - TH1F **hd0D0ptLSCfromBPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCfromBPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCfromBPM=new TH1F*[fnbins]; - TH1F **hd0D0ptLSCfromBSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCfromBSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCfromBSB=new TH1F*[fnbins]; + TH1F *hd0D0ptLSCfromBPM; + TH1F *hMCd0D0ptLSCfromBPM; + TH1F *hd0D0VtxTrueptLSCfromBPM; + TH1F *hd0D0ptLSCfromBSB; + TH1F *hMCd0D0ptLSCfromBSB; + TH1F *hd0D0VtxTrueptLSCfromBSB; namehist="hd0D0ptLSCfromB_"; titlehist="D^{0} impact par. plot, Loose Cuts, FromB, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCfromBPM[i]->SetYTitle("Entries"); - flistLsCutsFromB->Add(hd0D0ptLSCfromBPM[i]); + hd0D0ptLSCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCfromBPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCfromBPM->SetYTitle("Entries"); + flistLsCutsFromB->Add(hd0D0ptLSCfromBPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCfromBPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCfromBPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCfromBPM[i]->SetYTitle("Entries"); - flistLsCutsFromB->Add(hMCd0D0ptLSCfromBPM[i]); + hMCd0D0ptLSCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCfromBPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCfromBPM->SetYTitle("Entries"); + flistLsCutsFromB->Add(hMCd0D0ptLSCfromBPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCfromBPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCfromBPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCfromBPM[i]->SetYTitle("Entries"); - flistLsCutsFromB->Add(hd0D0VtxTrueptLSCfromBPM[i]); + hd0D0VtxTrueptLSCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCfromBPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCfromBPM->SetYTitle("Entries"); + flistLsCutsFromB->Add(hd0D0VtxTrueptLSCfromBPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1544,22 +2809,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptLSCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptLSCfromBSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCfromBSB[i]->SetYTitle("Entries"); - flistLsCutsFromB->Add(hd0D0ptLSCfromBSB[i]); + hd0D0ptLSCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCfromBSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCfromBSB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hd0D0ptLSCfromBSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCfromBSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCfromBSB[i]->SetYTitle("Entries"); - flistLsCutsFromB->Add(hMCd0D0ptLSCfromBSB[i]); + hMCd0D0ptLSCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCfromBSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCfromBSB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hMCd0D0ptLSCfromBSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCfromBSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCfromBSB[i]->SetYTitle("Entries"); - flistLsCutsFromB->Add(hd0D0VtxTrueptLSCfromBSB[i]); + hd0D0VtxTrueptLSCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCfromBSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCfromBSB->SetYTitle("Entries"); + flistLsCutsFromB->Add(hd0D0VtxTrueptLSCfromBSB); } @@ -1567,13 +2832,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() //############ LOOSE CUTS FROM DSTAR HISTOGRAMS ########### // //############## global properties histos - TH2F *hCPtaVSd0d0LSCfromDstar=new TH2F("hCPtaVSd0d0LSCfromDstar","hCPtaVSd0d0_LooseCuts_FromDStar",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0LSCfromDstar=new TH2F("hCPtaVSd0d0LSCfromDstar","hCPtaVSd0d0_LooseCuts_FromDStar",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZLSCfromDstar=new TH1F("hSecVtxZLSCfromDstar","hSecVtxZ_LooseCuts_FromDStar",1000,-8.,8.); TH1F *hSecVtxXLSCfromDstar=new TH1F("hSecVtxXLSCfromDstar","hSecVtxX_LooseCuts_FromDStar",1000,-3000.,3000.); TH1F *hSecVtxYLSCfromDstar=new TH1F("hSecVtxYLSCfromDstar","hSecVtxY_LooseCuts_FromDStar",1000,-3000.,3000.); TH2F *hSecVtxXYLSCfromDstar=new TH2F("hSecVtxXYLSCfromDstar","hSecVtxXY_LooseCuts_FromDStar",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiLSCfromDstar=new TH1F("hSecVtxPhiLSCfromDstar","hSecVtxPhi_LooseCuts_FromDStar",180,-180.1,180.1); - TH1F *hCPtaLSCfromDstar=new TH1F("hCPtaLSCfromDstar","hCPta_LooseCuts_FromDStar",100,0.,1.); + TH1F *hd0singlTrackLSCfromDstar=new TH1F("hd0singlTrackLSCfromDstar","hd0singlTrackLooseCuts_FromDstar",1000,-5000.,5000.); + TH1F *hCPtaLSCfromDstar=new TH1F("hCPtaLSCfromDstar","hCPta_LooseCuts_FromDStar",100,-1.,1.); TH1F *hd0xd0LSCfromDstar=new TH1F("hd0xd0LSCfromDstar","hd0xd0_LooseCuts_FromDStar",1000,-100000.,100000.); TH1F *hMassTrueLSCfromDstar=new TH1F("hMassTrueLSCfromDstar","D^{0} MC inv. Mass Loose Cuts FromDStar(All momenta)",600,1.600,2.200); TH1F *hMassLSCfromDstar=new TH1F("hMassLSCfromDstar","D^{0} inv. Mass Loose Cuts FromDStar (All momenta)",600,1.600,2.200); @@ -1591,15 +2857,162 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsFromDstar->Add(hSecVtxXLSCfromDstar); flistLsCutsFromDstar->Add(hSecVtxXYLSCfromDstar); flistLsCutsFromDstar->Add(hSecVtxPhiLSCfromDstar); + flistLsCutsFromDstar->Add(hd0singlTrackLSCfromDstar); flistLsCutsFromDstar->Add(hCPtaLSCfromDstar); flistLsCutsFromDstar->Add(hd0xd0LSCfromDstar); flistLsCutsFromDstar->Add(hMassTrueLSCfromDstar); flistLsCutsFromDstar->Add(hMassLSCfromDstar); - flistLsCutsFromDstar->Add(hMassTrueLSCfromDstarPM); + flistLsCutsFromDstar->Add(hMassTrueLSCfromDstarPM); flistLsCutsFromDstar->Add(hMassLSCfromDstarPM); flistLsCutsFromDstar->Add(hMassTrueLSCfromDstarSB); flistLsCutsFromDstar->Add(hMassLSCfromDstarSB); + + + + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaLSCfromDstar=new TH1F("hdcaLSCfromDstar","hdca_LooseCuts_FromDstar",100,0.,1000.); + hdcaLSCfromDstar->SetXTitle("dca [#mum]"); + hdcaLSCfromDstar->SetYTitle("Entries"); + TH1F *hcosthetastarLSCfromDstar=new TH1F("hcosthetastarLSCfromDstar","hCosThetaStar_LooseCuts_FromDstar",50,-1.,1.); + hcosthetastarLSCfromDstar->SetXTitle("cos #theta^{*}"); + hcosthetastarLSCfromDstar->SetYTitle("Entries"); + TH1F *hptD0LSCfromDstar=new TH1F("hptD0LSCfromDstar","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0LSCfromDstar->SetXTitle("p_{t} [GeV/c]"); + hptD0LSCfromDstar->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtLSCfromDstar=new TH1F("hptD0VsMaxPtLSCfromDstar","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtLSCfromDstar=new TH2F("hptD0PTallsqrtLSCfromDstar","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallLSCfromDstar=new TH2F("hptD0PTallLSCfromDstar","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBLSCfromDstar=new TH2F("hptD0vsptBLSCfromDstar","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBLSCfromDstar=new TH2F("hpD0vspBLSCfromDstar","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkLSCfromDstar=new TH2F("hptD0vsptcquarkLSCfromDstar","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkLSCfromDstar=new TH2F("hpD0vspcquarkLSCfromDstar","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistLsCutsFromDstar->Add(hdcaLSCfromDstar); + flistLsCutsFromDstar->Add(hcosthetastarLSCfromDstar); + flistLsCutsFromDstar->Add(hptD0LSCfromDstar); + flistLsCutsFromDstar->Add(hptD0VsMaxPtLSCfromDstar); + flistLsCutsFromDstar->Add(hptD0PTallsqrtLSCfromDstar); + flistLsCutsFromDstar->Add(hptD0PTallLSCfromDstar); + flistLsCutsFromDstar->Add(hptD0vsptBLSCfromDstar); + flistLsCutsFromDstar->Add(hpD0vspBLSCfromDstar); + flistLsCutsFromDstar->Add(hptD0vsptcquarkLSCfromDstar); + flistLsCutsFromDstar->Add(hpD0vspcquarkLSCfromDstar); + + TH1F *hd0zD0ptLSCfromDstar; + TH1F *hInvMassLSCfromDstar; + TH2F *hInvMassPtLSCfromDstar=new TH2F("hInvMassPtLSCfromDstar","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaLSCfromDstar; + TH1F *hCosPDPBLSCfromDstar; + TH1F *hCosPcPDLSCfromDstar; + flistLsCutsFromDstar->Add(hInvMassPtLSCfromDstar); + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0LSCfromDstarpt; + TH2F *hangletracksVSd0xd0LSCfromDstarpt; + TH2F *hangletracksVSd0D0LSCfromDstarpt; + TH1F *hd0xd0LSCfromDstarpt; + + TH2F *hTOFpidLSCfromDstar=new TH2F("hTOFpidLSCfromDstar","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistLsCutsFromDstar->Add(hTOFpidLSCfromDstar); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptLSCfromDstar->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hd0zD0ptLSCfromDstar); + + namehist="hInvMassLSCfromDstar_pt"; + namehist+=i; + titlehist="Invariant Mass Loose Cuts FromDstar ptbin="; + titlehist+=i; + hInvMassLSCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassLSCfromDstar->SetXTitle("Invariant Mass [GeV]"); + hInvMassLSCfromDstar->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hInvMassLSCfromDstar); + + namehist="hetaLSCfromDstar_pt"; + namehist+=i; + titlehist="eta Loose Cuts FromDstar ptbin="; + titlehist+=i; + hetaLSCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaLSCfromDstar->SetXTitle("Pseudorapidity"); + hetaLSCfromDstar->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hetaLSCfromDstar); + + namehist="hCosPDPBLSCfromDstar_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBLSCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBLSCfromDstar->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBLSCfromDstar->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hCosPDPBLSCfromDstar); + + namehist="hCosPcPDLSCfromDstar_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDLSCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDLSCfromDstar->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDLSCfromDstar->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hCosPcPDLSCfromDstar); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0LSCfromDstar_pt"; + namehist+=i; + titlehist="d0xd0 Loose Cuts FromDstar ptbin="; + titlehist+=i; + hd0xd0LSCfromDstarpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0LSCfromDstarpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0LSCfromDstarpt->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hd0xd0LSCfromDstarpt); + + + namehist="hd0D0VSd0xd0LSCfromDstar_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts FromDstar ptbin="; + titlehist+=i; + hd0D0VSd0xd0LSCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0LSCfromDstarpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0LSCfromDstarpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistLsCutsFromDstar->Add(hd0D0VSd0xd0LSCfromDstarpt); + + + namehist="hangletracksVSd0xd0LSCfromDstar_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts FromDstar ptbin="; + titlehist+=i; + hangletracksVSd0xd0LSCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0LSCfromDstarpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0LSCfromDstarpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsFromDstar->Add(hangletracksVSd0xd0LSCfromDstarpt); + + + namehist="hangletracksVSd0D0LSCfromDstar_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Loose Cuts FromDstar ptbin="; + titlehist+=i; + hangletracksVSd0D0LSCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0LSCfromDstarpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0LSCfromDstarpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsFromDstar->Add(hangletracksVSd0D0LSCfromDstarpt); + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + + //########## d0 D0 histos ############# TH1F *hd0D0LSCfromDstPM = new TH1F("hd0D0LSCfromDstarPM","D^{0} impact par. plot , Loose Cuts ,FromDStar,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0LSCfromDstPM->SetXTitle("Impact parameter [#mum]"); @@ -1632,12 +3045,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsFromDstar->Add(hd0D0VtxTrueLSCfromDstSB); flistLsCutsFromDstar->Add(hMCd0D0LSCfromDstSB); - TH1F **hd0D0ptLSCfromDstPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCfromDstPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCfromDstPM=new TH1F*[fnbins]; - TH1F **hd0D0ptLSCfromDstSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCfromDstSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCfromDstSB=new TH1F*[fnbins]; + TH1F *hd0D0ptLSCfromDstPM; + TH1F *hMCd0D0ptLSCfromDstPM; + TH1F *hd0D0VtxTrueptLSCfromDstPM; + TH1F *hd0D0ptLSCfromDstSB; + TH1F *hMCd0D0ptLSCfromDstSB; + TH1F *hd0D0VtxTrueptLSCfromDstSB; namehist="hd0D0ptLSCfromDstar_"; titlehist="D^{0} impact par. plot, Loose Cuts, FromDStar, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCfromDstPM[i]->SetYTitle("Entries"); - flistLsCutsFromDstar->Add(hd0D0ptLSCfromDstPM[i]); + hd0D0ptLSCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCfromDstPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCfromDstPM->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hd0D0ptLSCfromDstPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCfromDstPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCfromDstPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCfromDstPM[i]->SetYTitle("Entries"); - flistLsCutsFromDstar->Add(hMCd0D0ptLSCfromDstPM[i]); + hMCd0D0ptLSCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCfromDstPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCfromDstPM->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hMCd0D0ptLSCfromDstPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCfromDstPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCfromDstPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCfromDstPM[i]->SetYTitle("Entries"); - flistLsCutsFromDstar->Add(hd0D0VtxTrueptLSCfromDstPM[i]); + hd0D0VtxTrueptLSCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCfromDstPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCfromDstPM->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hd0D0VtxTrueptLSCfromDstPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1681,22 +3094,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptLSCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptLSCfromDstSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCfromDstSB[i]->SetYTitle("Entries"); - flistLsCutsFromDstar->Add(hd0D0ptLSCfromDstSB[i]); + hd0D0ptLSCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCfromDstSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCfromDstSB->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hd0D0ptLSCfromDstSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCfromDstSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCfromDstSB[i]->SetYTitle("Entries"); - flistLsCutsFromDstar->Add(hMCd0D0ptLSCfromDstSB[i]); + hMCd0D0ptLSCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCfromDstSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCfromDstSB->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hMCd0D0ptLSCfromDstSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCfromDstSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCfromDstSB[i]->SetYTitle("Entries"); - flistLsCutsFromDstar->Add(hd0D0VtxTrueptLSCfromDstSB[i]); + hd0D0VtxTrueptLSCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCfromDstSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCfromDstSB->SetYTitle("Entries"); + flistLsCutsFromDstar->Add(hd0D0VtxTrueptLSCfromDstSB); } @@ -1704,13 +3117,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //########### global properties histos ########### - TH2F *hCPtaVSd0d0LSCother=new TH2F("hCPtaVSd0d0LSCother","hCPtaVSd0d0_LooseCuts_other",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0LSCother=new TH2F("hCPtaVSd0d0LSCother","hCPtaVSd0d0_LooseCuts_other",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZLSCother=new TH1F("hSecVtxZLSCother","hSecVtxZ_LooseCuts_other",1000,-8.,8.); TH1F *hSecVtxXLSCother=new TH1F("hSecVtxXLSCother","hSecVtxX_LooseCuts_other",1000,-3000.,3000.); TH1F *hSecVtxYLSCother=new TH1F("hSecVtxYLSCother","hSecVtxY_LooseCuts_other",1000,-3000.,3000.); TH2F *hSecVtxXYLSCother=new TH2F("hSecVtxXYLSCother","hSecVtxXY_LooseCuts_other",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiLSCother=new TH1F("hSecVtxPhiLSCother","hSecVtxPhi_LooseCuts_other",180,-180.1,180.1); - TH1F *hCPtaLSCother=new TH1F("hCPtaLSCother","hCPta_LooseCuts_other",100,0.,1.); + TH1F *hd0singlTrackLSCother=new TH1F("hd0singlTrackLSCother","hd0singlTrackLooseCuts_Other",1000,-5000.,5000.); + TH1F *hCPtaLSCother=new TH1F("hCPtaLSCother","hCPta_LooseCuts_other",100,-1.,1.); TH1F *hd0xd0LSCother=new TH1F("hd0xd0LSCother","hd0xd0_LooseCuts_other",1000,-100000.,100000.); TH1F *hMassTrueLSCother=new TH1F("hMassTrueLSCother","D^{0} MC inv. Mass Loose Cuts other(All momenta)",600,1.600,2.200); TH1F *hMassLSCother=new TH1F("hMassLSCother","D^{0} inv. Mass Loose Cuts other (All momenta)",600,1.600,2.200); @@ -1728,6 +3142,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsOther->Add(hSecVtxXLSCother); flistLsCutsOther->Add(hSecVtxXYLSCother); flistLsCutsOther->Add(hSecVtxPhiLSCother); + flistLsCutsOther->Add(hd0singlTrackLSCother); flistLsCutsOther->Add(hCPtaLSCother); flistLsCutsOther->Add(hd0xd0LSCother); flistLsCutsOther->Add(hMassTrueLSCother); @@ -1737,6 +3152,146 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsOther->Add(hMassTrueLSCotherSB); flistLsCutsOther->Add(hMassLSCotherSB); + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaLSCother=new TH1F("hdcaLSCother","hdca_LooseCuts_Other",100,0.,1000.); + hdcaLSCother->SetXTitle("dca [#mum]"); + hdcaLSCother->SetYTitle("Entries"); + TH1F *hcosthetastarLSCother=new TH1F("hcosthetastarLSCother","hCosThetaStar_LooseCuts_Other",50,-1.,1.); + hcosthetastarLSCother->SetXTitle("cos #theta^{*}"); + hcosthetastarLSCother->SetYTitle("Entries"); + TH1F *hptD0LSCother=new TH1F("hptD0LSCother","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0LSCother->SetXTitle("p_{t} [GeV/c]"); + hptD0LSCother->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtLSCother=new TH1F("hptD0VsMaxPtLSCother","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtLSCother=new TH2F("hptD0PTallsqrtLSCother","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallLSCother=new TH2F("hptD0PTallLSCother","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBLSCother=new TH2F("hptD0vsptBLSCother","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBLSCother=new TH2F("hpD0vspBLSCother","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkLSCother=new TH2F("hptD0vsptcquarkLSCother","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkLSCother=new TH2F("hpD0vspcquarkLSCother","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistLsCutsOther->Add(hdcaLSCother); + flistLsCutsOther->Add(hcosthetastarLSCother); + flistLsCutsOther->Add(hptD0LSCother); + flistLsCutsOther->Add(hptD0VsMaxPtLSCother); + flistLsCutsOther->Add(hptD0PTallsqrtLSCother); + flistLsCutsOther->Add(hptD0PTallLSCother); + flistLsCutsOther->Add(hptD0vsptBLSCother); + flistLsCutsOther->Add(hpD0vspBLSCother); + flistLsCutsOther->Add(hptD0vsptcquarkLSCother); + flistLsCutsOther->Add(hpD0vspcquarkLSCother); + + TH1F *hd0zD0ptLSCother; + TH1F *hInvMassLSCother; + TH2F *hInvMassPtLSCother=new TH2F("hInvMassPtLSCother","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaLSCother; + TH1F *hCosPDPBLSCother; + TH1F *hCosPcPDLSCother; + flistLsCutsOther->Add(hInvMassPtLSCother); + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0LSCotherpt; + TH2F *hangletracksVSd0xd0LSCotherpt; + TH2F *hangletracksVSd0D0LSCotherpt; + TH1F *hd0xd0LSCotherpt; + + TH2F *hTOFpidLSCother=new TH2F("hTOFpidLSCother","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistLsCutsOther->Add(hTOFpidLSCother); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptLSCother->SetYTitle("Entries"); + flistLsCutsOther->Add(hd0zD0ptLSCother); + + namehist="hInvMassLSCother_pt"; + namehist+=i; + titlehist="Invariant Mass Loose Cuts Other ptbin="; + titlehist+=i; + hInvMassLSCother=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassLSCother->SetXTitle("Invariant Mass [GeV]"); + hInvMassLSCother->SetYTitle("Entries"); + flistLsCutsOther->Add(hInvMassLSCother); + + namehist="hetaLSCother_pt"; + namehist+=i; + titlehist="eta Loose Cuts Other ptbin="; + titlehist+=i; + hetaLSCother=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaLSCother->SetXTitle("Pseudorapidity"); + hetaLSCother->SetYTitle("Entries"); + flistLsCutsOther->Add(hetaLSCother); + + namehist="hCosPDPBLSCother_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBLSCother=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBLSCother->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBLSCother->SetYTitle("Entries"); + flistLsCutsOther->Add(hCosPDPBLSCother); + + namehist="hCosPcPDLSCother_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDLSCother=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDLSCother->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDLSCother->SetYTitle("Entries"); + flistLsCutsOther->Add(hCosPcPDLSCother); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0LSCother_pt"; + namehist+=i; + titlehist="d0xd0 Loose Cuts Other ptbin="; + titlehist+=i; + hd0xd0LSCotherpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0LSCotherpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0LSCotherpt->SetYTitle("Entries"); + flistLsCutsOther->Add(hd0xd0LSCotherpt); + + + namehist="hd0D0VSd0xd0LSCother_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts Other ptbin="; + titlehist+=i; + hd0D0VSd0xd0LSCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0LSCotherpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0LSCotherpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistLsCutsOther->Add(hd0D0VSd0xd0LSCotherpt); + + + namehist="hangletracksVSd0xd0LSCother_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Loose Cuts Other ptbin="; + titlehist+=i; + hangletracksVSd0xd0LSCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0LSCotherpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0LSCotherpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsOther->Add(hangletracksVSd0xd0LSCotherpt); + + + namehist="hangletracksVSd0D0LSCother_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Loose Cuts Other ptbin="; + titlehist+=i; + hangletracksVSd0D0LSCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0LSCotherpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0LSCotherpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistLsCutsOther->Add(hangletracksVSd0D0LSCotherpt); + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + //############# d0 D0 histos ###############à TH1F *hd0D0LSCotherPM = new TH1F("hd0D0LSCotherPM","D^{0} impact par. plot , Loose Cuts ,Other,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0LSCotherPM->SetXTitle("Impact parameter [#mum]"); @@ -1769,12 +3324,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistLsCutsOther->Add(hd0D0VtxTrueLSCotherSB); flistLsCutsOther->Add(hMCd0D0LSCotherSB); - TH1F **hd0D0ptLSCotherPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCotherPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCotherPM=new TH1F*[fnbins]; - TH1F **hd0D0ptLSCotherSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptLSCotherSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptLSCotherSB=new TH1F*[fnbins]; + TH1F *hd0D0ptLSCotherPM; + TH1F *hMCd0D0ptLSCotherPM; + TH1F *hd0D0VtxTrueptLSCotherPM; + TH1F *hd0D0ptLSCotherSB; + TH1F *hMCd0D0ptLSCotherSB; + TH1F *hd0D0VtxTrueptLSCotherSB; namehist="hd0D0ptLSCother_"; titlehist="D^{0} impact par. plot, Loose Cuts, Other, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCotherPM[i]->SetYTitle("Entries"); - flistLsCutsOther->Add(hd0D0ptLSCotherPM[i]); + hd0D0ptLSCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCotherPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCotherPM->SetYTitle("Entries"); + flistLsCutsOther->Add(hd0D0ptLSCotherPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCotherPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCotherPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCotherPM[i]->SetYTitle("Entries"); - flistLsCutsOther->Add(hMCd0D0ptLSCotherPM[i]); + hMCd0D0ptLSCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCotherPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCotherPM->SetYTitle("Entries"); + flistLsCutsOther->Add(hMCd0D0ptLSCotherPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCotherPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCotherPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCotherPM[i]->SetYTitle("Entries"); - flistLsCutsOther->Add(hd0D0VtxTrueptLSCotherPM[i]); + hd0D0VtxTrueptLSCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCotherPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCotherPM->SetYTitle("Entries"); + flistLsCutsOther->Add(hd0D0VtxTrueptLSCotherPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1818,25 +3373,25 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptLSCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptLSCotherSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptLSCotherSB[i]->SetYTitle("Entries"); - flistLsCutsOther->Add(hd0D0ptLSCotherSB[i]); + hd0D0ptLSCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptLSCotherSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptLSCotherSB->SetYTitle("Entries"); + flistLsCutsOther->Add(hd0D0ptLSCotherSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptLSCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptLSCotherSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptLSCotherSB[i]->SetYTitle("Entries"); - flistLsCutsOther->Add(hMCd0D0ptLSCotherSB[i]); + hMCd0D0ptLSCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptLSCotherSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptLSCotherSB->SetYTitle("Entries"); + flistLsCutsOther->Add(hMCd0D0ptLSCotherSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptLSCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptLSCotherSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptLSCotherSB[i]->SetYTitle("Entries"); - flistLsCutsOther->Add(hd0D0VtxTrueptLSCotherSB[i]); + hd0D0VtxTrueptLSCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptLSCotherSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptLSCotherSB->SetYTitle("Entries"); + flistLsCutsOther->Add(hd0D0VtxTrueptLSCotherSB); } - + Printf("END OF NOCUTS HISTOS CREATION \n"); //################################################################################################ @@ -1849,13 +3404,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // // ####### global properties histo ############ - TH2F *hCPtaVSd0d0TGHCsign=new TH2F("hCPtaVSd0d0TGHCsign","hCPtaVSd0d0_TightCuts_Signal",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0TGHCsign=new TH2F("hCPtaVSd0d0TGHCsign","hCPtaVSd0d0_TightCuts_Signal",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZTGHCsign=new TH1F("hSecVtxZTGHCsign","hSecVtxZ_TightCuts_Signal",1000,-8.,8.); TH1F *hSecVtxXTGHCsign=new TH1F("hSecVtxXTGHCsign","hSecVtxX_TightCuts_Signal",1000,-3000.,3000.); TH1F *hSecVtxYTGHCsign=new TH1F("hSecVtxYTGHCsign","hSecVtxY_TightCuts_Signal",1000,-3000.,3000.); TH2F *hSecVtxXYTGHCsign=new TH2F("hSecVtxXYTGHCsign","hSecVtxXY_TightCuts_Signal",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiTGHCsign=new TH1F("hSecVtxPhiTGHCsign","hSecVtxPhi_TightCuts_Signal",180,-180.1,180.1); - TH1F *hCPtaTGHCsign=new TH1F("hCPtaTGHCsign","hCPta_TightCuts_Signal",100,0.,1.); + TH1F *hd0singlTrackTGHCsign=new TH1F("hd0singlTrackTGHCsign","hd0singlTrackTightCuts_Signal",1000,-5000.,5000.); + TH1F *hCPtaTGHCsign=new TH1F("hCPtaTGHCsign","hCPta_TightCuts_Signal",100,-1.,1.); TH1F *hd0xd0TGHCsign=new TH1F("hd0xd0TGHCsign","hd0xd0_TightCuts_Signal",1000,-100000.,100000.); TH1F *hMassTrueTGHCsign=new TH1F("hMassTrueTGHCsign","D^{0} MC inv. Mass Tight Cuts Signal(All momenta)",600,1.600,2.200); TH1F *hMassTGHCsign=new TH1F("hMassTGHCsign","D^{0} inv. Mass Tight Cuts Signal (All momenta)",600,1.600,2.200); @@ -1873,6 +3429,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsSignal->Add(hSecVtxXTGHCsign); flistTghCutsSignal->Add(hSecVtxXYTGHCsign); flistTghCutsSignal->Add(hSecVtxPhiTGHCsign); + flistTghCutsSignal->Add(hd0singlTrackTGHCsign); flistTghCutsSignal->Add(hCPtaTGHCsign); flistTghCutsSignal->Add(hd0xd0TGHCsign); flistTghCutsSignal->Add(hMassTrueTGHCsign); @@ -1882,6 +3439,153 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsSignal->Add(hMassTrueTGHCsignSB); flistTghCutsSignal->Add(hMassTGHCsignSB); + + + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaTGHCsign=new TH1F("hdcaTGHCsign","hdca_TightCuts_Signal",100,0.,1000.); + hdcaTGHCsign->SetXTitle("dca [#mum]"); + hdcaTGHCsign->SetYTitle("Entries"); + TH1F *hcosthetastarTGHCsign=new TH1F("hcosthetastarTGHCsign","hCosThetaStar_TightCuts_Signal",50,-1.,1.); + hcosthetastarTGHCsign->SetXTitle("cos #theta^{*}"); + hcosthetastarTGHCsign->SetYTitle("Entries"); + TH1F *hptD0TGHCsign=new TH1F("hptD0TGHCsign","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0TGHCsign->SetXTitle("p_{t} [GeV/c]"); + hptD0TGHCsign->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtTGHCsign=new TH1F("hptD0VsMaxPtTGHCsign","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtTGHCsign=new TH2F("hptD0PTallsqrtTGHCsign","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallTGHCsign=new TH2F("hptD0PTallTGHCsign","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBTGHCsign=new TH2F("hptD0vsptBTGHCsign","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBTGHCsign=new TH2F("hpD0vspBTGHCsign","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkTGHCsign=new TH2F("hptD0vsptcquarkTGHCsign","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkTGHCsign=new TH2F("hpD0vspcquarkTGHCsign","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistTghCutsSignal->Add(hdcaTGHCsign); + flistTghCutsSignal->Add(hcosthetastarTGHCsign); + flistTghCutsSignal->Add(hptD0TGHCsign); + flistTghCutsSignal->Add(hptD0VsMaxPtTGHCsign); + flistTghCutsSignal->Add(hptD0PTallsqrtTGHCsign); + flistTghCutsSignal->Add(hptD0PTallTGHCsign); + flistTghCutsSignal->Add(hptD0vsptBTGHCsign); + flistTghCutsSignal->Add(hpD0vspBTGHCsign); + flistTghCutsSignal->Add(hptD0vsptcquarkTGHCsign); + flistTghCutsSignal->Add(hpD0vspcquarkTGHCsign); + + TH1F *hd0zD0ptTGHCsign; + TH1F *hInvMassTGHCsign; + TH2F *hInvMassPtTGHCsign=new TH2F("hInvMassPtTGHCsign","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaTGHCsign; + TH1F *hCosPDPBTGHCsign; + TH1F *hCosPcPDTGHCsign; + flistTghCutsSignal->Add(hInvMassPtTGHCsign); +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0TGHCsignpt; + TH2F *hangletracksVSd0xd0TGHCsignpt; + TH2F *hangletracksVSd0D0TGHCsignpt; + TH1F *hd0xd0TGHCsignpt; + + TH2F *hTOFpidTGHCsign=new TH2F("hTOFpidTGHCsign","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistTghCutsSignal->Add(hTOFpidTGHCsign); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptTGHCsign->SetYTitle("Entries"); + flistTghCutsSignal->Add(hd0zD0ptTGHCsign); + + namehist="hInvMassTGHCsign_pt"; + namehist+=i; + titlehist="Invariant Mass Tight Cuts Signal ptbin="; + titlehist+=i; + hInvMassTGHCsign=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassTGHCsign->SetXTitle("Invariant Mass [GeV]"); + hInvMassTGHCsign->SetYTitle("Entries"); + flistTghCutsSignal->Add(hInvMassTGHCsign); + + namehist="hetaTGHCsign_pt"; + namehist+=i; + titlehist="eta Tight Cuts Signal ptbin="; + titlehist+=i; + hetaTGHCsign=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaTGHCsign->SetXTitle("Pseudorapidity"); + hetaTGHCsign->SetYTitle("Entries"); + flistTghCutsSignal->Add(hetaTGHCsign); + + namehist="hCosPDPBTGHCsign_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBTGHCsign=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBTGHCsign->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBTGHCsign->SetYTitle("Entries"); + flistTghCutsSignal->Add(hCosPDPBTGHCsign); + + namehist="hCosPcPDTGHCsign_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDTGHCsign=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDTGHCsign->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDTGHCsign->SetYTitle("Entries"); + flistTghCutsSignal->Add(hCosPcPDTGHCsign); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0TGHCsign_pt"; + namehist+=i; + titlehist="d0xd0 Tight Cuts Signal ptbin="; + titlehist+=i; + hd0xd0TGHCsignpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0TGHCsignpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0TGHCsignpt->SetYTitle("Entries"); + flistTghCutsSignal->Add(hd0xd0TGHCsignpt); + + + namehist="hd0D0VSd0xd0TGHCsign_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts Signal ptbin="; + titlehist+=i; + hd0D0VSd0xd0TGHCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0TGHCsignpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0TGHCsignpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistTghCutsSignal->Add(hd0D0VSd0xd0TGHCsignpt); + + + namehist="hangletracksVSd0xd0TGHCsign_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts Signal ptbin="; + titlehist+=i; + hangletracksVSd0xd0TGHCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0TGHCsignpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0TGHCsignpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsSignal->Add(hangletracksVSd0xd0TGHCsignpt); + + + namehist="hangletracksVSd0D0TGHCsign_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Tight Cuts Signal ptbin="; + titlehist+=i; + hangletracksVSd0D0TGHCsignpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0TGHCsignpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0TGHCsignpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsSignal->Add(hangletracksVSd0D0TGHCsignpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + + + + // ####### d0 D0 histos ############ TH1F *hd0D0TGHCsignPM = new TH1F("hd0D0TGHCsignPM","D^{0} impact par. plot , Tight Cuts ,Signal,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0TGHCsignPM->SetXTitle("Impact parameter [#mum]"); @@ -1914,12 +3618,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsSignal->Add(hd0D0VtxTrueTGHCsignSB); flistTghCutsSignal->Add(hMCd0D0TGHCsignSB); - TH1F **hd0D0ptTGHCsignPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCsignPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCsignPM=new TH1F*[fnbins]; - TH1F **hd0D0ptTGHCsignSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCsignSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCsignSB=new TH1F*[fnbins]; + TH1F *hd0D0ptTGHCsignPM; + TH1F *hMCd0D0ptTGHCsignPM; + TH1F *hd0D0VtxTrueptTGHCsignPM; + TH1F *hd0D0ptTGHCsignSB; + TH1F *hMCd0D0ptTGHCsignSB; + TH1F *hd0D0VtxTrueptTGHCsignSB; namehist="hd0D0ptTGHCsign_"; titlehist="D^{0} impact par. plot, Tight Cuts, Signal, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCsignPM[i]->SetYTitle("Entries"); - flistTghCutsSignal->Add(hd0D0ptTGHCsignPM[i]); + hd0D0ptTGHCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCsignPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCsignPM->SetYTitle("Entries"); + flistTghCutsSignal->Add(hd0D0ptTGHCsignPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCsignPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCsignPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCsignPM[i]->SetYTitle("Entries"); - flistTghCutsSignal->Add(hMCd0D0ptTGHCsignPM[i]); + hMCd0D0ptTGHCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCsignPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCsignPM->SetYTitle("Entries"); + flistTghCutsSignal->Add(hMCd0D0ptTGHCsignPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCsignPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCsignPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCsignPM[i]->SetYTitle("Entries"); - flistTghCutsSignal->Add(hd0D0VtxTrueptTGHCsignPM[i]); + hd0D0VtxTrueptTGHCsignPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCsignPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCsignPM->SetYTitle("Entries"); + flistTghCutsSignal->Add(hd0D0VtxTrueptTGHCsignPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -1963,35 +3667,36 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptTGHCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptTGHCsignSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCsignSB[i]->SetYTitle("Entries"); - flistTghCutsSignal->Add(hd0D0ptTGHCsignSB[i]); + hd0D0ptTGHCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCsignSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCsignSB->SetYTitle("Entries"); + flistTghCutsSignal->Add(hd0D0ptTGHCsignSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCsignSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCsignSB[i]->SetYTitle("Entries"); - flistTghCutsSignal->Add(hMCd0D0ptTGHCsignSB[i]); + hMCd0D0ptTGHCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCsignSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCsignSB->SetYTitle("Entries"); + flistTghCutsSignal->Add(hMCd0D0ptTGHCsignSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCsignSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCsignSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCsignSB[i]->SetYTitle("Entries"); - flistTghCutsSignal->Add(hd0D0VtxTrueptTGHCsignSB[i]); + hd0D0VtxTrueptTGHCsignSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCsignSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCsignSB->SetYTitle("Entries"); + flistTghCutsSignal->Add(hd0D0VtxTrueptTGHCsignSB); } //############ TIGHT CUTS BACKGROUND HISTOGRAMS ########### // // ######## global properties histos ####### - TH2F *hCPtaVSd0d0TGHCback=new TH2F("hCPtaVSd0d0TGHCback","hCPtaVSd0d0_TightCuts_Background",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0TGHCback=new TH2F("hCPtaVSd0d0TGHCback","hCPtaVSd0d0_TightCuts_Background",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZTGHCback=new TH1F("hSecVtxZTGHCback","hSecVtxZ_TightCuts_Background",1000,-8.,8.); TH1F *hSecVtxXTGHCback=new TH1F("hSecVtxXTGHCback","hSecVtxX_TightCuts_Background",1000,-3000.,3000.); TH1F *hSecVtxYTGHCback=new TH1F("hSecVtxYTGHCback","hSecVtxY_TightCuts_Background",1000,-3000.,3000.); TH2F *hSecVtxXYTGHCback=new TH2F("hSecVtxXYTGHCback","hSecVtxXY_TightCuts_Background",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiTGHCback=new TH1F("hSecVtxPhiTGHCback","hSecVtxPhi_TightCuts_Background",180,-180.1,180.1); - TH1F *hCPtaTGHCback=new TH1F("hCPtaTGHCback","hCPta_TightCuts_Background",100,0.,1.); + TH1F *hd0singlTrackTGHCback=new TH1F("hd0singlTrackTGHCback","hd0singlTrackTightCuts_Back",1000,-5000.,5000.); + TH1F *hCPtaTGHCback=new TH1F("hCPtaTGHCback","hCPta_TightCuts_Background",100,-1.,1.); TH1F *hd0xd0TGHCback=new TH1F("hd0xd0TGHCback","hd0xd0_TightCuts_Background",1000,-100000.,100000.); TH1F *hMassTrueTGHCback=new TH1F("hMassTrueTGHCback","D^{0} MC inv. Mass Tight Cuts Background(All momenta)",600,1.600,2.200); TH1F *hMassTGHCback=new TH1F("hMassTGHCback","D^{0} inv. Mass Tight Cuts Background (All momenta)",600,1.600,2.200); @@ -2009,6 +3714,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsBack->Add(hSecVtxXTGHCback); flistTghCutsBack->Add(hSecVtxXYTGHCback); flistTghCutsBack->Add(hSecVtxPhiTGHCback); + flistTghCutsBack->Add(hd0singlTrackTGHCback); flistTghCutsBack->Add(hCPtaTGHCback); flistTghCutsBack->Add(hd0xd0TGHCback); flistTghCutsBack->Add(hMassTrueTGHCback); @@ -2019,6 +3725,150 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsBack->Add(hMassTGHCbackSB); + + + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaTGHCback=new TH1F("hdcaTGHCback","hdca_TightCuts_Backgr",100,0.,1000.); + hdcaTGHCback->SetXTitle("dca [#mum]"); + hdcaTGHCback->SetYTitle("Entries"); + TH1F *hcosthetastarTGHCback=new TH1F("hcosthetastarTGHCback","hCosThetaStar_TightCuts_Backgr",50,-1.,1.); + hcosthetastarTGHCback->SetXTitle("cos #theta^{*}"); + hcosthetastarTGHCback->SetYTitle("Entries"); + TH1F *hptD0TGHCback=new TH1F("hptD0TGHCback","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0TGHCback->SetXTitle("p_{t} [GeV/c]"); + hptD0TGHCback->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtTGHCback=new TH1F("hptD0VsMaxPtTGHCback","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtTGHCback=new TH2F("hptD0PTallsqrtTGHCback","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallTGHCback=new TH2F("hptD0PTallTGHCback","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBTGHCback=new TH2F("hptD0vsptBTGHCback","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBTGHCback=new TH2F("hpD0vspBTGHCback","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkTGHCback=new TH2F("hptD0vsptcquarkTGHCback","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkTGHCback=new TH2F("hpD0vspcquarkTGHCback","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistTghCutsBack->Add(hdcaTGHCback); + flistTghCutsBack->Add(hcosthetastarTGHCback); + flistTghCutsBack->Add(hptD0TGHCback); + flistTghCutsBack->Add(hptD0VsMaxPtTGHCback); + flistTghCutsBack->Add(hptD0PTallsqrtTGHCback); + flistTghCutsBack->Add(hptD0PTallTGHCback); + flistTghCutsBack->Add(hptD0vsptBTGHCback); + flistTghCutsBack->Add(hpD0vspBTGHCback); + flistTghCutsBack->Add(hptD0vsptcquarkTGHCback); + flistTghCutsBack->Add(hpD0vspcquarkTGHCback); + + TH1F *hd0zD0ptTGHCback; + TH1F *hInvMassTGHCback; + TH2F *hInvMassPtTGHCback=new TH2F("hInvMassPtTGHCback","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaTGHCback; + TH1F *hCosPDPBTGHCback; + TH1F *hCosPcPDTGHCback; + flistTghCutsBack->Add(hInvMassPtTGHCback); +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0TGHCbackpt; + TH2F *hangletracksVSd0xd0TGHCbackpt; + TH2F *hangletracksVSd0D0TGHCbackpt; + TH1F *hd0xd0TGHCbackpt; + + TH2F *hTOFpidTGHCback=new TH2F("hTOFpidTGHCback","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistTghCutsBack->Add(hTOFpidTGHCback); + + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptTGHCback->SetYTitle("Entries"); + flistTghCutsBack->Add(hd0zD0ptTGHCback); + + namehist="hInvMassTGHCback_pt"; + namehist+=i; + titlehist="Invariant Mass Tight Cuts Backgr ptbin="; + titlehist+=i; + hInvMassTGHCback=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassTGHCback->SetXTitle("Invariant Mass [GeV]"); + hInvMassTGHCback->SetYTitle("Entries"); + flistTghCutsBack->Add(hInvMassTGHCback); + + namehist="hetaTGHCback_pt"; + namehist+=i; + titlehist="eta Tight Cuts Backgr ptbin="; + titlehist+=i; + hetaTGHCback=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaTGHCback->SetXTitle("Pseudorapidity"); + hetaTGHCback->SetYTitle("Entries"); + flistTghCutsBack->Add(hetaTGHCback); + + namehist="hCosPDPBTGHCback_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBTGHCback=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBTGHCback->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBTGHCback->SetYTitle("Entries"); + flistTghCutsBack->Add(hCosPDPBTGHCback); + + namehist="hCosPcPDTGHCback_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDTGHCback=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDTGHCback->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDTGHCback->SetYTitle("Entries"); + flistTghCutsBack->Add(hCosPcPDTGHCback); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0TGHCback_pt"; + namehist+=i; + titlehist="d0xd0 Tight Cuts Back ptbin="; + titlehist+=i; + hd0xd0TGHCbackpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0TGHCbackpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0TGHCbackpt->SetYTitle("Entries"); + flistTghCutsBack->Add(hd0xd0TGHCbackpt); + + + namehist="hd0D0VSd0xd0TGHCback_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts Back ptbin="; + titlehist+=i; + hd0D0VSd0xd0TGHCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0TGHCbackpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0TGHCbackpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistTghCutsBack->Add(hd0D0VSd0xd0TGHCbackpt); + + + namehist="hangletracksVSd0xd0TGHCback_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts Back ptbin="; + titlehist+=i; + hangletracksVSd0xd0TGHCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0TGHCbackpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0TGHCbackpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsBack->Add(hangletracksVSd0xd0TGHCbackpt); + + + namehist="hangletracksVSd0D0TGHCback_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Tight Cuts Back ptbin="; + titlehist+=i; + hangletracksVSd0D0TGHCbackpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0TGHCbackpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0TGHCbackpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsBack->Add(hangletracksVSd0D0TGHCbackpt); + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + // ####### d0 D0 histos ############ TH1F *hd0D0TGHCbackPM = new TH1F("hd0D0TGHCbackPM","D^{0} impact par. plot , Tight Cuts ,Background,Mass Peak (All momenta)",1000,-1000.,1000.); @@ -2052,12 +3902,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsBack->Add(hd0D0VtxTrueTGHCbackSB); flistTghCutsBack->Add(hMCd0D0TGHCbackSB); - TH1F **hd0D0ptTGHCbackPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCbackPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCbackPM=new TH1F*[fnbins]; - TH1F **hd0D0ptTGHCbackSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCbackSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCbackSB=new TH1F*[fnbins]; + TH1F *hd0D0ptTGHCbackPM; + TH1F *hMCd0D0ptTGHCbackPM; + TH1F *hd0D0VtxTrueptTGHCbackPM; + TH1F *hd0D0ptTGHCbackSB; + TH1F *hMCd0D0ptTGHCbackSB; + TH1F *hd0D0VtxTrueptTGHCbackSB; namehist="hd0D0ptTGHCback_"; titlehist="D^{0} impact par. plot, Tight Cuts, Background, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCbackPM[i]->SetYTitle("Entries"); - flistTghCutsBack->Add(hd0D0ptTGHCbackPM[i]); + hd0D0ptTGHCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCbackPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCbackPM->SetYTitle("Entries"); + flistTghCutsBack->Add(hd0D0ptTGHCbackPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCbackPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCbackPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCbackPM[i]->SetYTitle("Entries"); - flistTghCutsBack->Add(hMCd0D0ptTGHCbackPM[i]); + hMCd0D0ptTGHCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCbackPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCbackPM->SetYTitle("Entries"); + flistTghCutsBack->Add(hMCd0D0ptTGHCbackPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCbackPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCbackPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCbackPM[i]->SetYTitle("Entries"); - flistTghCutsBack->Add(hd0D0VtxTrueptTGHCbackPM[i]); + hd0D0VtxTrueptTGHCbackPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCbackPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCbackPM->SetYTitle("Entries"); + flistTghCutsBack->Add(hd0D0VtxTrueptTGHCbackPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -2101,22 +3951,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptTGHCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptTGHCbackSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCbackSB[i]->SetYTitle("Entries"); - flistTghCutsBack->Add(hd0D0ptTGHCbackSB[i]); + hd0D0ptTGHCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCbackSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCbackSB->SetYTitle("Entries"); + flistTghCutsBack->Add(hd0D0ptTGHCbackSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCbackSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCbackSB[i]->SetYTitle("Entries"); - flistTghCutsBack->Add(hMCd0D0ptTGHCbackSB[i]); + hMCd0D0ptTGHCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCbackSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCbackSB->SetYTitle("Entries"); + flistTghCutsBack->Add(hMCd0D0ptTGHCbackSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCbackSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCbackSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCbackSB[i]->SetYTitle("Entries"); - flistTghCutsBack->Add(hd0D0VtxTrueptTGHCbackSB[i]); + hd0D0VtxTrueptTGHCbackSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCbackSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCbackSB->SetYTitle("Entries"); + flistTghCutsBack->Add(hd0D0VtxTrueptTGHCbackSB); } @@ -2125,13 +3975,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //####### global properties histos - TH2F *hCPtaVSd0d0TGHCfromB=new TH2F("hCPtaVSd0d0TGHCfromB","hCPtaVSd0d0_TightCuts_FromB",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0TGHCfromB=new TH2F("hCPtaVSd0d0TGHCfromB","hCPtaVSd0d0_TightCuts_FromB",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZTGHCfromB=new TH1F("hSecVtxZTGHCfromB","hSecVtxZ_TightCuts_FromB",1000,-8.,8.); TH1F *hSecVtxXTGHCfromB=new TH1F("hSecVtxXTGHCfromB","hSecVtxX_TightCuts_FromB",1000,-3000.,3000.); TH1F *hSecVtxYTGHCfromB=new TH1F("hSecVtxYTGHCfromB","hSecVtxY_TightCuts_FromB",1000,-3000.,3000.); TH2F *hSecVtxXYTGHCfromB=new TH2F("hSecVtxXYTGHCfromB","hSecVtxXY_TightCuts_FromB",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiTGHCfromB=new TH1F("hSecVtxPhiTGHCfromB","hSecVtxPhi_TightCuts_FromB",180,-180.1,180.1); - TH1F *hCPtaTGHCfromB=new TH1F("hCPtaTGHCfromB","hCPta_TightCuts_FromB",100,0.,1.); + TH1F *hd0singlTrackTGHCfromB=new TH1F("hd0singlTrackTGHCfromB","hd0singlTrackTightCuts_FromB",1000,-5000.,5000.); + TH1F *hCPtaTGHCfromB=new TH1F("hCPtaTGHCfromB","hCPta_TightCuts_FromB",100,-1.,1.); TH1F *hd0xd0TGHCfromB=new TH1F("hd0xd0TGHCfromB","hd0xd0_TightCuts_FromB",1000,-100000.,100000.); TH1F *hMassTrueTGHCfromB=new TH1F("hMassTrueTGHCfromB","D^{0} MC inv. Mass Tight Cuts FromB(All momenta)",600,1.600,2.200); TH1F *hMassTGHCfromB=new TH1F("hMassTGHCfromB","D^{0} inv. Mass Tight Cuts FromB (All momenta)",600,1.600,2.200); @@ -2149,6 +4000,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsFromB->Add(hSecVtxXTGHCfromB); flistTghCutsFromB->Add(hSecVtxXYTGHCfromB); flistTghCutsFromB->Add(hSecVtxPhiTGHCfromB); + flistTghCutsFromB->Add(hd0singlTrackTGHCfromB); flistTghCutsFromB->Add(hCPtaTGHCfromB); flistTghCutsFromB->Add(hd0xd0TGHCfromB); flistTghCutsFromB->Add(hMassTrueTGHCfromB); @@ -2158,20 +4010,161 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsFromB->Add(hMassTrueTGHCfromBSB); flistTghCutsFromB->Add(hMassTGHCfromBSB); - // ######### d0 D0 histos ############## - TH1F *hd0D0TGHCfromBPM = new TH1F("hd0D0TGHCfromBPM","D^{0} impact par. plot , Tight Cuts ,FromB,Mass Peak (All momenta)",1000,-1000.,1000.); - hd0D0TGHCfromBPM->SetXTitle("Impact parameter [#mum]"); - hd0D0TGHCfromBPM->SetYTitle("Entries"); - TH1F *hd0D0VtxTrueTGHCfromBPM = new TH1F("hd0D0VtxTrueTGHCfromBPM","D^{0} impact par. w.r.t. True Vtx, Tight Cuts, FromB,Mass Peak (All momenta)",1000,-1000.,1000.); - hd0D0VtxTrueTGHCfromBPM->SetXTitle("Impact parameter [#mum]"); - hd0D0VtxTrueTGHCfromBPM->SetYTitle("Entries"); - TH1F *hMCd0D0TGHCfromBPM = new TH1F("hMCd0D0TGHCfromBPM","D^{0} impact par. plot, Tight Cuts, FromB,Mass Peak (All momenta)",1000,-1000.,1000.); - hMCd0D0TGHCfromBPM->SetXTitle("MC Impact parameter [#mum]"); - hMCd0D0TGHCfromBPM->SetYTitle("Entries"); + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaTGHCfromB=new TH1F("hdcaTGHCfromB","hdca_TightCuts_FromB",100,0.,1000.); + hdcaTGHCfromB->SetXTitle("dca [#mum]"); + hdcaTGHCfromB->SetYTitle("Entries"); + TH1F *hcosthetastarTGHCfromB=new TH1F("hcosthetastarTGHCfromB","hCosThetaStar_TightCuts_FromB",50,-1.,1.); + hcosthetastarTGHCfromB->SetXTitle("cos #theta^{*}"); + hcosthetastarTGHCfromB->SetYTitle("Entries"); + TH1F *hptD0TGHCfromB=new TH1F("hptD0TGHCfromB","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0TGHCfromB->SetXTitle("p_{t} [GeV/c]"); + hptD0TGHCfromB->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtTGHCfromB=new TH1F("hptD0VsMaxPtTGHCfromB","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtTGHCfromB=new TH2F("hptD0PTallsqrtTGHCfromB","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallTGHCfromB=new TH2F("hptD0PTallTGHCfromB","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBTGHCfromB=new TH2F("hptD0vsptBTGHCfromB","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBTGHCfromB=new TH2F("hpD0vspBTGHCfromB","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkTGHCfromB=new TH2F("hptD0vsptcquarkTGHCfromB","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkTGHCfromB=new TH2F("hpD0vspcquarkTGHCfromB","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistTghCutsFromB->Add(hdcaTGHCfromB); + flistTghCutsFromB->Add(hcosthetastarTGHCfromB); + flistTghCutsFromB->Add(hptD0TGHCfromB); + flistTghCutsFromB->Add(hptD0VsMaxPtTGHCfromB); + flistTghCutsFromB->Add(hptD0PTallsqrtTGHCfromB); + flistTghCutsFromB->Add(hptD0PTallTGHCfromB); + flistTghCutsFromB->Add(hptD0vsptBTGHCfromB); + flistTghCutsFromB->Add(hpD0vspBTGHCfromB); + flistTghCutsFromB->Add(hptD0vsptcquarkTGHCfromB); + flistTghCutsFromB->Add(hpD0vspcquarkTGHCfromB); + + TH1F *hd0zD0ptTGHCfromB; + TH1F *hInvMassTGHCfromB; + TH2F *hInvMassPtTGHCfromB=new TH2F("hInvMassPtTGHCfromB","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaTGHCfromB; + TH1F *hCosPDPBTGHCfromB; + TH1F *hCosPcPDTGHCfromB; + flistTghCutsFromB->Add(hInvMassPtTGHCfromB); +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0TGHCfromBpt; + TH2F *hangletracksVSd0xd0TGHCfromBpt; + TH2F *hangletracksVSd0D0TGHCfromBpt; + TH1F *hd0xd0TGHCfromBpt; + + TH2F *hTOFpidTGHCfromB=new TH2F("hTOFpidTGHCfromB","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistTghCutsFromB->Add(hTOFpidTGHCfromB); - TH1F *hd0D0TGHCfromBSB = new TH1F("hd0D0TGHCfromBSB","D^{0} impact par. plot , Tight Cuts ,FromB,Mass Peak (All momenta)",1000,-1000.,1000.); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptTGHCfromB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hd0zD0ptTGHCfromB); + + namehist="hInvMassTGHCfromB_pt"; + namehist+=i; + titlehist="Invariant Mass Tight Cuts FromB ptbin="; + titlehist+=i; + hInvMassTGHCfromB=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassTGHCfromB->SetXTitle("Invariant Mass [GeV]"); + hInvMassTGHCfromB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hInvMassTGHCfromB); + + namehist="hetaTGHCfromB_pt"; + namehist+=i; + titlehist="eta Tight Cuts FromB ptbin="; + titlehist+=i; + hetaTGHCfromB=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaTGHCfromB->SetXTitle("Pseudorapidity"); + hetaTGHCfromB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hetaTGHCfromB); + + namehist="hCosPDPBTGHCfromB_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBTGHCfromB=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBTGHCfromB->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBTGHCfromB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hCosPDPBTGHCfromB); + + namehist="hCosPcPDTGHCfromB_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDTGHCfromB=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDTGHCfromB->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDTGHCfromB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hCosPcPDTGHCfromB); + +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0TGHCfromB_pt"; + namehist+=i; + titlehist="d0xd0 Tight Cuts FromB ptbin="; + titlehist+=i; + hd0xd0TGHCfromBpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0TGHCfromBpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0TGHCfromBpt->SetYTitle("Entries"); + flistTghCutsFromB->Add(hd0xd0TGHCfromBpt); + + + namehist="hd0D0VSd0xd0TGHCfromB_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts FromB ptbin="; + titlehist+=i; + hd0D0VSd0xd0TGHCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0TGHCfromBpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0TGHCfromBpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistTghCutsFromB->Add(hd0D0VSd0xd0TGHCfromBpt); + + + namehist="hangletracksVSd0xd0TGHCfromB_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts FromB ptbin="; + titlehist+=i; + hangletracksVSd0xd0TGHCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0TGHCfromBpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0TGHCfromBpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsFromB->Add(hangletracksVSd0xd0TGHCfromBpt); + + + namehist="hangletracksVSd0D0TGHCfromB_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Tight Cuts FromB ptbin="; + titlehist+=i; + hangletracksVSd0D0TGHCfromBpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0TGHCfromBpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0TGHCfromBpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsFromB->Add(hangletracksVSd0D0TGHCfromBpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + + // ######### d0 D0 histos ############## + TH1F *hd0D0TGHCfromBPM = new TH1F("hd0D0TGHCfromBPM","D^{0} impact par. plot , Tight Cuts ,FromB,Mass Peak (All momenta)",1000,-1000.,1000.); + hd0D0TGHCfromBPM->SetXTitle("Impact parameter [#mum]"); + hd0D0TGHCfromBPM->SetYTitle("Entries"); + + TH1F *hd0D0VtxTrueTGHCfromBPM = new TH1F("hd0D0VtxTrueTGHCfromBPM","D^{0} impact par. w.r.t. True Vtx, Tight Cuts, FromB,Mass Peak (All momenta)",1000,-1000.,1000.); + hd0D0VtxTrueTGHCfromBPM->SetXTitle("Impact parameter [#mum]"); + hd0D0VtxTrueTGHCfromBPM->SetYTitle("Entries"); + + TH1F *hMCd0D0TGHCfromBPM = new TH1F("hMCd0D0TGHCfromBPM","D^{0} impact par. plot, Tight Cuts, FromB,Mass Peak (All momenta)",1000,-1000.,1000.); + hMCd0D0TGHCfromBPM->SetXTitle("MC Impact parameter [#mum]"); + hMCd0D0TGHCfromBPM->SetYTitle("Entries"); + + TH1F *hd0D0TGHCfromBSB = new TH1F("hd0D0TGHCfromBSB","D^{0} impact par. plot , Tight Cuts ,FromB,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0TGHCfromBSB->SetXTitle("Impact parameter [#mum]"); hd0D0TGHCfromBSB->SetYTitle("Entries"); @@ -2190,12 +4183,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsFromB->Add(hd0D0VtxTrueTGHCfromBSB); flistTghCutsFromB->Add(hMCd0D0TGHCfromBSB); - TH1F **hd0D0ptTGHCfromBPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCfromBPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCfromBPM=new TH1F*[fnbins]; - TH1F **hd0D0ptTGHCfromBSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCfromBSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCfromBSB=new TH1F*[fnbins]; + TH1F *hd0D0ptTGHCfromBPM; + TH1F *hMCd0D0ptTGHCfromBPM; + TH1F *hd0D0VtxTrueptTGHCfromBPM; + TH1F *hd0D0ptTGHCfromBSB; + TH1F *hMCd0D0ptTGHCfromBSB; + TH1F *hd0D0VtxTrueptTGHCfromBSB; namehist="hd0D0ptTGHCfromB_"; titlehist="D^{0} impact par. plot, Tight Cuts, FromB, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCfromBPM[i]->SetYTitle("Entries"); - flistTghCutsFromB->Add(hd0D0ptTGHCfromBPM[i]); + hd0D0ptTGHCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCfromBPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCfromBPM->SetYTitle("Entries"); + flistTghCutsFromB->Add(hd0D0ptTGHCfromBPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCfromBPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCfromBPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCfromBPM[i]->SetYTitle("Entries"); - flistTghCutsFromB->Add(hMCd0D0ptTGHCfromBPM[i]); + hMCd0D0ptTGHCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCfromBPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCfromBPM->SetYTitle("Entries"); + flistTghCutsFromB->Add(hMCd0D0ptTGHCfromBPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCfromBPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCfromBPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCfromBPM[i]->SetYTitle("Entries"); - flistTghCutsFromB->Add(hd0D0VtxTrueptTGHCfromBPM[i]); + hd0D0VtxTrueptTGHCfromBPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCfromBPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCfromBPM->SetYTitle("Entries"); + flistTghCutsFromB->Add(hd0D0VtxTrueptTGHCfromBPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -2239,22 +4232,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptTGHCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptTGHCfromBSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCfromBSB[i]->SetYTitle("Entries"); - flistTghCutsFromB->Add(hd0D0ptTGHCfromBSB[i]); + hd0D0ptTGHCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCfromBSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCfromBSB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hd0D0ptTGHCfromBSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCfromBSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCfromBSB[i]->SetYTitle("Entries"); - flistTghCutsFromB->Add(hMCd0D0ptTGHCfromBSB[i]); + hMCd0D0ptTGHCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCfromBSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCfromBSB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hMCd0D0ptTGHCfromBSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCfromBSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCfromBSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCfromBSB[i]->SetYTitle("Entries"); - flistTghCutsFromB->Add(hd0D0VtxTrueptTGHCfromBSB[i]); + hd0D0VtxTrueptTGHCfromBSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCfromBSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCfromBSB->SetYTitle("Entries"); + flistTghCutsFromB->Add(hd0D0VtxTrueptTGHCfromBSB); } @@ -2262,13 +4255,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() //############ TIGHT CUTS FROM DSTAR HISTOGRAMS ########### // //############## global properties histos - TH2F *hCPtaVSd0d0TGHCfromDstar=new TH2F("hCPtaVSd0d0TGHCfromDstar","hCPtaVSd0d0_TightCuts_FromDStar",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0TGHCfromDstar=new TH2F("hCPtaVSd0d0TGHCfromDstar","hCPtaVSd0d0_TightCuts_FromDStar",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZTGHCfromDstar=new TH1F("hSecVtxZTGHCfromDstar","hSecVtxZ_TightCuts_FromDStar",1000,-8.,8.); TH1F *hSecVtxXTGHCfromDstar=new TH1F("hSecVtxXTGHCfromDstar","hSecVtxX_TightCuts_FromDStar",1000,-3000.,3000.); TH1F *hSecVtxYTGHCfromDstar=new TH1F("hSecVtxYTGHCfromDstar","hSecVtxY_TightCuts_FromDStar",1000,-3000.,3000.); TH2F *hSecVtxXYTGHCfromDstar=new TH2F("hSecVtxXYTGHCfromDstar","hSecVtxXY_TightCuts_FromDStar",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiTGHCfromDstar=new TH1F("hSecVtxPhiTGHCfromDstar","hSecVtxPhi_TightCuts_FromDStar",180,-180.1,180.1); - TH1F *hCPtaTGHCfromDstar=new TH1F("hCPtaTGHCfromDstar","hCPta_TightCuts_FromDStar",100,0.,1.); + TH1F *hd0singlTrackTGHCfromDstar=new TH1F("hd0singlTrackTGHCfromDstar","hd0singlTrackTightCuts_FromDstar",1000,-5000.,5000.); + TH1F *hCPtaTGHCfromDstar=new TH1F("hCPtaTGHCfromDstar","hCPta_TightCuts_FromDStar",100,-1.,1.); TH1F *hd0xd0TGHCfromDstar=new TH1F("hd0xd0TGHCfromDstar","hd0xd0_TightCuts_FromDStar",1000,-100000.,100000.); TH1F *hMassTrueTGHCfromDstar=new TH1F("hMassTrueTGHCfromDstar","D^{0} MC inv. Mass Tight Cuts FromDStar(All momenta)",600,1.600,2.200); TH1F *hMassTGHCfromDstar=new TH1F("hMassTGHCfromDstar","D^{0} inv. Mass Tight Cuts FromDStar (All momenta)",600,1.600,2.200); @@ -2286,6 +4280,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsFromDstar->Add(hSecVtxXTGHCfromDstar); flistTghCutsFromDstar->Add(hSecVtxXYTGHCfromDstar); flistTghCutsFromDstar->Add(hSecVtxPhiTGHCfromDstar); + flistTghCutsFromDstar->Add(hd0singlTrackTGHCfromDstar); flistTghCutsFromDstar->Add(hCPtaTGHCfromDstar); flistTghCutsFromDstar->Add(hd0xd0TGHCfromDstar); flistTghCutsFromDstar->Add(hMassTrueTGHCfromDstar); @@ -2295,6 +4290,146 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsFromDstar->Add(hMassTrueTGHCfromDstarSB); flistTghCutsFromDstar->Add(hMassTGHCfromDstarSB); + + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaTGHCfromDstar=new TH1F("hdcaTGHCfromDstar","hdca_TightCuts_FromDstar",100,0.,1000.); + hdcaTGHCfromDstar->SetXTitle("dca [#mum]"); + hdcaTGHCfromDstar->SetYTitle("Entries"); + TH1F *hcosthetastarTGHCfromDstar=new TH1F("hcosthetastarTGHCfromDstar","hCosThetaStar_TightCuts_FromDstar",50,-1.,1.); + hcosthetastarTGHCfromDstar->SetXTitle("cos #theta^{*}"); + hcosthetastarTGHCfromDstar->SetYTitle("Entries"); + TH1F *hptD0TGHCfromDstar=new TH1F("hptD0TGHCfromDstar","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0TGHCfromDstar->SetXTitle("p_{t} [GeV/c]"); + hptD0TGHCfromDstar->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtTGHCfromDstar=new TH1F("hptD0VsMaxPtTGHCfromDstar","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtTGHCfromDstar=new TH2F("hptD0PTallsqrtTGHCfromDstar","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallTGHCfromDstar=new TH2F("hptD0PTallTGHCfromDstar","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBTGHCfromDstar=new TH2F("hptD0vsptBTGHCfromDstar","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBTGHCfromDstar=new TH2F("hpD0vspBTGHCfromDstar","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkTGHCfromDstar=new TH2F("hptD0vsptcquarkTGHCfromDstar","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkTGHCfromDstar=new TH2F("hpD0vspcquarkTGHCfromDstar","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistTghCutsFromDstar->Add(hdcaTGHCfromDstar); + flistTghCutsFromDstar->Add(hcosthetastarTGHCfromDstar); + flistTghCutsFromDstar->Add(hptD0TGHCfromDstar); + flistTghCutsFromDstar->Add(hptD0VsMaxPtTGHCfromDstar); + flistTghCutsFromDstar->Add(hptD0PTallsqrtTGHCfromDstar); + flistTghCutsFromDstar->Add(hptD0PTallTGHCfromDstar); + flistTghCutsFromDstar->Add(hptD0vsptBTGHCfromDstar); + flistTghCutsFromDstar->Add(hpD0vspBTGHCfromDstar); + flistTghCutsFromDstar->Add(hptD0vsptcquarkTGHCfromDstar); + flistTghCutsFromDstar->Add(hpD0vspcquarkTGHCfromDstar); + + TH1F *hd0zD0ptTGHCfromDstar; + TH1F *hInvMassTGHCfromDstar; + TH1F *hetaTGHCfromDstar; + TH2F *hInvMassPtTGHCfromDstar=new TH2F("hInvMassPtTGHCfromDstar","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hCosPDPBTGHCfromDstar; + TH1F *hCosPcPDTGHCfromDstar; + flistTghCutsFromDstar->Add(hInvMassPtTGHCfromDstar); +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0TGHCfromDstarpt; + TH2F *hangletracksVSd0xd0TGHCfromDstarpt; + TH2F *hangletracksVSd0D0TGHCfromDstarpt; + TH1F *hd0xd0TGHCfromDstarpt; + + TH2F *hTOFpidTGHCfromDstar=new TH2F("hTOFpidTGHCfromDstar","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistTghCutsFromDstar->Add(hTOFpidTGHCfromDstar); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptTGHCfromDstar->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hd0zD0ptTGHCfromDstar); + + namehist="hInvMassTGHCfromDstar_pt"; + namehist+=i; + titlehist="Invariant Mass Tight Cuts FromDstar ptbin="; + titlehist+=i; + hInvMassTGHCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassTGHCfromDstar->SetXTitle("Invariant Mass [GeV]"); + hInvMassTGHCfromDstar->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hInvMassTGHCfromDstar); + + namehist="hetaTGHCfromDstar_pt"; + namehist+=i; + titlehist="eta Tight Cuts FromDstar ptbin="; + titlehist+=i; + hetaTGHCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaTGHCfromDstar->SetXTitle("Pseudorapidity"); + hetaTGHCfromDstar->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hetaTGHCfromDstar); + + namehist="hCosPDPBTGHCfromDstar_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBTGHCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBTGHCfromDstar->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBTGHCfromDstar->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hCosPDPBTGHCfromDstar); + + namehist="hCosPcPDTGHCfromDstar_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDTGHCfromDstar=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDTGHCfromDstar->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDTGHCfromDstar->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hCosPcPDTGHCfromDstar); + + // %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0TGHCfromDstar_pt"; + namehist+=i; + titlehist="d0xd0 Tight Cuts FromDstar ptbin="; + titlehist+=i; + hd0xd0TGHCfromDstarpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0TGHCfromDstarpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0TGHCfromDstarpt->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hd0xd0TGHCfromDstarpt); + + + namehist="hd0D0VSd0xd0TGHCfromDstar_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts FromDstar ptbin="; + titlehist+=i; + hd0D0VSd0xd0TGHCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0TGHCfromDstarpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0TGHCfromDstarpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistTghCutsFromDstar->Add(hd0D0VSd0xd0TGHCfromDstarpt); + + + namehist="hangletracksVSd0xd0TGHCfromDstar_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts FromDstar ptbin="; + titlehist+=i; + hangletracksVSd0xd0TGHCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0TGHCfromDstarpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0TGHCfromDstarpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsFromDstar->Add(hangletracksVSd0xd0TGHCfromDstarpt); + + + namehist="hangletracksVSd0D0TGHCfromDstar_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Tight Cuts FromDstar ptbin="; + titlehist+=i; + hangletracksVSd0D0TGHCfromDstarpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0TGHCfromDstarpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0TGHCfromDstarpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsFromDstar->Add(hangletracksVSd0D0TGHCfromDstarpt); + + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + //########## d0 D0 histos ############# TH1F *hd0D0TGHCfromDstPM = new TH1F("hd0D0TGHCfromDstarPM","D^{0} impact par. plot , Tight Cuts ,FromDStar,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0TGHCfromDstPM->SetXTitle("Impact parameter [#mum]"); @@ -2327,12 +4462,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsFromDstar->Add(hd0D0VtxTrueTGHCfromDstSB); flistTghCutsFromDstar->Add(hMCd0D0TGHCfromDstSB); - TH1F **hd0D0ptTGHCfromDstPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCfromDstPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCfromDstPM=new TH1F*[fnbins]; - TH1F **hd0D0ptTGHCfromDstSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCfromDstSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCfromDstSB=new TH1F*[fnbins]; + TH1F *hd0D0ptTGHCfromDstPM; + TH1F *hMCd0D0ptTGHCfromDstPM; + TH1F *hd0D0VtxTrueptTGHCfromDstPM; + TH1F *hd0D0ptTGHCfromDstSB; + TH1F *hMCd0D0ptTGHCfromDstSB; + TH1F *hd0D0VtxTrueptTGHCfromDstSB; namehist="hd0D0ptTGHCfromDstar_"; titlehist="D^{0} impact par. plot, Tight Cuts, FromDStar, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCfromDstPM[i]->SetYTitle("Entries"); - flistTghCutsFromDstar->Add(hd0D0ptTGHCfromDstPM[i]); + hd0D0ptTGHCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCfromDstPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCfromDstPM->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hd0D0ptTGHCfromDstPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCfromDstPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCfromDstPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCfromDstPM[i]->SetYTitle("Entries"); - flistTghCutsFromDstar->Add(hMCd0D0ptTGHCfromDstPM[i]); + hMCd0D0ptTGHCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCfromDstPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCfromDstPM->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hMCd0D0ptTGHCfromDstPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCfromDstPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCfromDstPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCfromDstPM[i]->SetYTitle("Entries"); - flistTghCutsFromDstar->Add(hd0D0VtxTrueptTGHCfromDstPM[i]); + hd0D0VtxTrueptTGHCfromDstPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCfromDstPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCfromDstPM->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hd0D0VtxTrueptTGHCfromDstPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -2376,22 +4511,22 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptTGHCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptTGHCfromDstSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCfromDstSB[i]->SetYTitle("Entries"); - flistTghCutsFromDstar->Add(hd0D0ptTGHCfromDstSB[i]); + hd0D0ptTGHCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCfromDstSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCfromDstSB->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hd0D0ptTGHCfromDstSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCfromDstSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCfromDstSB[i]->SetYTitle("Entries"); - flistTghCutsFromDstar->Add(hMCd0D0ptTGHCfromDstSB[i]); + hMCd0D0ptTGHCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCfromDstSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCfromDstSB->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hMCd0D0ptTGHCfromDstSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCfromDstSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCfromDstSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCfromDstSB[i]->SetYTitle("Entries"); - flistTghCutsFromDstar->Add(hd0D0VtxTrueptTGHCfromDstSB[i]); + hd0D0VtxTrueptTGHCfromDstSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCfromDstSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCfromDstSB->SetYTitle("Entries"); + flistTghCutsFromDstar->Add(hd0D0VtxTrueptTGHCfromDstSB); } @@ -2399,13 +4534,14 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() // //########### global properties histos ########### - TH2F *hCPtaVSd0d0TGHCother=new TH2F("hCPtaVSd0d0TGHCother","hCPtaVSd0d0_TightCuts_other",1000,-100000.,100000.,100,0.,1.); + TH2F *hCPtaVSd0d0TGHCother=new TH2F("hCPtaVSd0d0TGHCother","hCPtaVSd0d0_TightCuts_other",1000,-100000.,100000.,100,-1.,1.); TH1F *hSecVtxZTGHCother=new TH1F("hSecVtxZTGHCother","hSecVtxZ_TightCuts_other",1000,-8.,8.); TH1F *hSecVtxXTGHCother=new TH1F("hSecVtxXTGHCother","hSecVtxX_TightCuts_other",1000,-3000.,3000.); TH1F *hSecVtxYTGHCother=new TH1F("hSecVtxYTGHCother","hSecVtxY_TightCuts_other",1000,-3000.,3000.); TH2F *hSecVtxXYTGHCother=new TH2F("hSecVtxXYTGHCother","hSecVtxXY_TightCuts_other",1000,-3000.,3000.,1000,-3000.,3000.); TH1F *hSecVtxPhiTGHCother=new TH1F("hSecVtxPhiTGHCother","hSecVtxPhi_TightCuts_other",180,-180.1,180.1); - TH1F *hCPtaTGHCother=new TH1F("hCPtaTGHCother","hCPta_TightCuts_other",100,0.,1.); + TH1F *hd0singlTrackTGHCother=new TH1F("hd0singlTrackTGHCother","hd0singlTrackTightCuts_Other",1000,-5000.,5000.); + TH1F *hCPtaTGHCother=new TH1F("hCPtaTGHCother","hCPta_TightCuts_other",100,-1.,1.); TH1F *hd0xd0TGHCother=new TH1F("hd0xd0TGHCother","hd0xd0_TightCuts_other",1000,-100000.,100000.); TH1F *hMassTrueTGHCother=new TH1F("hMassTrueTGHCother","D^{0} MC inv. Mass Tight Cuts other(All momenta)",600,1.600,2.200); TH1F *hMassTGHCother=new TH1F("hMassTGHCother","D^{0} inv. Mass Tight Cuts other (All momenta)",600,1.600,2.200); @@ -2423,6 +4559,7 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsOther->Add(hSecVtxXTGHCother); flistTghCutsOther->Add(hSecVtxXYTGHCother); flistTghCutsOther->Add(hSecVtxPhiTGHCother); + flistTghCutsOther->Add(hd0singlTrackTGHCother); flistTghCutsOther->Add(hCPtaTGHCother); flistTghCutsOther->Add(hd0xd0TGHCother); flistTghCutsOther->Add(hMassTrueTGHCother); @@ -2432,6 +4569,147 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsOther->Add(hMassTrueTGHCotherSB); flistTghCutsOther->Add(hMassTGHCotherSB); + + + + //%%% NEW HISTOS %%%%%%%%%%%%%%%% + TH1F *hdcaTGHCother=new TH1F("hdcaTGHCother","hdca_TightCuts_Other",100,0.,1000.); + hdcaTGHCother->SetXTitle("dca [#mum]"); + hdcaTGHCother->SetYTitle("Entries"); + TH1F *hcosthetastarTGHCother=new TH1F("hcosthetastarTGHCother","hCosThetaStar_TightCuts_Other",50,-1.,1.); + hcosthetastarTGHCother->SetXTitle("cos #theta^{*}"); + hcosthetastarTGHCother->SetYTitle("Entries"); + TH1F *hptD0TGHCother=new TH1F("hptD0TGHCother","D^{0} transverse momentum distribution",34,ptbinsD0arr); + hptD0TGHCother->SetXTitle("p_{t} [GeV/c]"); + hptD0TGHCother->SetYTitle("Entries"); + TH1F *hptD0VsMaxPtTGHCother=new TH1F("hptD0VsMaxPtTGHCother","Difference between D^{0} pt and highest (or second) pt",400,-50.,50.); + TH2F *hptD0PTallsqrtTGHCother=new TH2F("hptD0PTallsqrtTGHCother","D^{0} pt Vs Sqrt(Sum pt square)",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0PTallTGHCother=new TH2F("hptD0PTallTGHCother","D^{0} pt Vs Sum pt ",34,ptbinsD0arr,200,dumbinning); + TH2F *hptD0vsptBTGHCother=new TH2F("hptD0vsptBTGHCother","D^{0} pt Vs B pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspBTGHCother=new TH2F("hpD0vspBTGHCother","D^{0} tot momentum Vs B tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hptD0vsptcquarkTGHCother=new TH2F("hptD0vsptcquarkTGHCother","D^{0} pt Vs cquark pt distribution",34,ptbinsD0arr,34,ptbinsD0arr); + TH2F *hpD0vspcquarkTGHCother=new TH2F("hpD0vspcquarkTGHCother","D^{0} tot momentum Vs cquark tot momentum distribution",34,ptbinsD0arr,34,ptbinsD0arr); + flistTghCutsOther->Add(hdcaTGHCother); + flistTghCutsOther->Add(hcosthetastarTGHCother); + flistTghCutsOther->Add(hptD0TGHCother); + flistTghCutsOther->Add(hptD0VsMaxPtTGHCother); + flistTghCutsOther->Add(hptD0PTallsqrtTGHCother); + flistTghCutsOther->Add(hptD0PTallTGHCother); + flistTghCutsOther->Add(hptD0vsptBTGHCother); + flistTghCutsOther->Add(hpD0vspBTGHCother); + flistTghCutsOther->Add(hptD0vsptcquarkTGHCother); + flistTghCutsOther->Add(hpD0vspcquarkTGHCother); + + TH1F *hd0zD0ptTGHCother; + TH1F *hInvMassTGHCother; + TH2F *hInvMassPtTGHCother=new TH2F("hInvMassPtTGHCother","Candidate p_{t} Vs invariant mass",330,1.700,2.030,200,0.,20.); + TH1F *hetaTGHCother; + TH1F *hCosPDPBTGHCother; + TH1F *hCosPcPDTGHCother; + flistTghCutsOther->Add(hInvMassPtTGHCother); +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + TH2F *hd0D0VSd0xd0TGHCotherpt; + TH2F *hangletracksVSd0xd0TGHCotherpt; + TH2F *hangletracksVSd0D0TGHCotherpt; + TH1F *hd0xd0TGHCotherpt; + + TH2F *hTOFpidTGHCother=new TH2F("hTOFpidTGHCother","TOF time VS momentum",10,0.,4.,50,-50000.,50000.); + flistTghCutsOther->Add(hTOFpidTGHCother); + + for(Int_t i=0;iSetXTitle("d_{0}(z) [#mum]"); + hd0zD0ptTGHCother->SetYTitle("Entries"); + flistTghCutsOther->Add(hd0zD0ptTGHCother); + + namehist="hInvMassTGHCother_pt"; + namehist+=i; + titlehist="Invariant Mass Tight Cuts Other ptbin="; + titlehist+=i; + hInvMassTGHCother=new TH1F(namehist.Data(),titlehist.Data(),600,1.600,2.200); + hInvMassTGHCother->SetXTitle("Invariant Mass [GeV]"); + hInvMassTGHCother->SetYTitle("Entries"); + flistTghCutsOther->Add(hInvMassTGHCother); + + namehist="hetaTGHCother_pt"; + namehist+=i; + titlehist="eta Tight Cuts Other ptbin="; + titlehist+=i; + hetaTGHCother=new TH1F(namehist.Data(),titlehist.Data(),100,-3.,3.); + hetaTGHCother->SetXTitle("Pseudorapidity"); + hetaTGHCother->SetYTitle("Entries"); + flistTghCutsOther->Add(hetaTGHCother); + + namehist="hCosPDPBTGHCother_pt"; + namehist+=i; + titlehist="Cosine between D0 momentum and B momentum, ptbin="; + titlehist+=i; + hCosPDPBTGHCother=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPDPBTGHCother->SetXTitle("Cosine between D0 momentum and B momentum"); + hCosPDPBTGHCother->SetYTitle("Entries"); + flistTghCutsOther->Add(hCosPDPBTGHCother); + + namehist="hCosPcPDTGHCother_pt"; + namehist+=i; + titlehist="Cosine between cquark momentum and D0 momentum, ptbin="; + titlehist+=i; + hCosPcPDTGHCother=new TH1F(namehist.Data(),titlehist.Data(),50,-1.,1.); + hCosPcPDTGHCother->SetXTitle("Cosine between c quark momentum and D0 momentum"); + hCosPcPDTGHCother->SetYTitle("Entries"); + flistTghCutsOther->Add(hCosPcPDTGHCother); + +// %%%%%%%%%%% HERE THE ADDITIONAL HISTS %%%%%%%%%%%%%%%%% + namehist="hd0xd0TGHCother_pt"; + namehist+=i; + titlehist="d0xd0 Tight Cuts Other ptbin="; + titlehist+=i; + hd0xd0TGHCotherpt=new TH1F(namehist.Data(),titlehist.Data(),1000,-50000.,10000.); + hd0xd0TGHCotherpt->SetXTitle("d_{0}^{K}xd_{0}^{#pi} [#mum^2]"); + hd0xd0TGHCotherpt->SetYTitle("Entries"); + flistTghCutsOther->Add(hd0xd0TGHCotherpt); + + + namehist="hd0D0VSd0xd0TGHCother_pt"; + namehist+=i; + titlehist="d_{0}^{D^{0}} Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts Other ptbin="; + titlehist+=i; + hd0D0VSd0xd0TGHCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,100,-300,300); + hd0D0VSd0xd0TGHCotherpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hd0D0VSd0xd0TGHCotherpt->SetYTitle(" d_{0}^{D^{0}} [#mum]"); + flistTghCutsOther->Add(hd0D0VSd0xd0TGHCotherpt); + + + namehist="hangletracksVSd0xd0TGHCother_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{K}xd_{0}^{#pi} Tight Cuts Other ptbin="; + titlehist+=i; + hangletracksVSd0xd0TGHCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-50000.,30000.,40,-0.1,3.24); + hangletracksVSd0xd0TGHCotherpt->SetXTitle(" d_{0}^{K}xd_{0}^{#pi} [#mum]"); + hangletracksVSd0xd0TGHCotherpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsOther->Add(hangletracksVSd0xd0TGHCotherpt); + + + namehist="hangletracksVSd0D0TGHCother_pt"; + namehist+=i; + titlehist="Angle between K and #pi tracks Vs d_{0}^{D^{0}} Tight Cuts Other ptbin="; + titlehist+=i; + hangletracksVSd0D0TGHCotherpt=new TH2F(namehist.Data(),titlehist.Data(),200,-400.,400.,40,-0.12,3.24); + hangletracksVSd0D0TGHCotherpt->SetXTitle(" d_{0}^{D^{0}} [#mum]"); + hangletracksVSd0D0TGHCotherpt->SetYTitle(" angle between K and #p tracks [rad]"); + flistTghCutsOther->Add(hangletracksVSd0D0TGHCotherpt); + + } + // %%%%%%%% END OF NEW HISTOS %%%%%%%%%%%%% + //%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + + + + + //############# d0 D0 histos ###############à TH1F *hd0D0TGHCotherPM = new TH1F("hd0D0TGHCotherPM","D^{0} impact par. plot , Tight Cuts ,Other,Mass Peak (All momenta)",1000,-1000.,1000.); hd0D0TGHCotherPM->SetXTitle("Impact parameter [#mum]"); @@ -2464,12 +4742,12 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() flistTghCutsOther->Add(hd0D0VtxTrueTGHCotherSB); flistTghCutsOther->Add(hMCd0D0TGHCotherSB); - TH1F **hd0D0ptTGHCotherPM=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCotherPM=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCotherPM=new TH1F*[fnbins]; - TH1F **hd0D0ptTGHCotherSB=new TH1F*[fnbins]; - TH1F **hMCd0D0ptTGHCotherSB=new TH1F*[fnbins]; - TH1F ** hd0D0VtxTrueptTGHCotherSB=new TH1F*[fnbins]; + TH1F *hd0D0ptTGHCotherPM; + TH1F *hMCd0D0ptTGHCotherPM; + TH1F *hd0D0VtxTrueptTGHCotherPM; + TH1F *hd0D0ptTGHCotherSB; + TH1F *hMCd0D0ptTGHCotherSB; + TH1F *hd0D0VtxTrueptTGHCotherSB; namehist="hd0D0ptTGHCother_"; titlehist="D^{0} impact par. plot, Tight Cuts, Other, "; for(Int_t i=0;iSetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCotherPM[i]->SetYTitle("Entries"); - flistTghCutsOther->Add(hd0D0ptTGHCotherPM[i]); + hd0D0ptTGHCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCotherPM->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCotherPM->SetYTitle("Entries"); + flistTghCutsOther->Add(hd0D0ptTGHCotherPM); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCotherPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCotherPM[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCotherPM[i]->SetYTitle("Entries"); - flistTghCutsOther->Add(hMCd0D0ptTGHCotherPM[i]); + hMCd0D0ptTGHCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCotherPM->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCotherPM->SetYTitle("Entries"); + flistTghCutsOther->Add(hMCd0D0ptTGHCotherPM); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCotherPM[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCotherPM[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCotherPM[i]->SetYTitle("Entries"); - flistTghCutsOther->Add(hd0D0VtxTrueptTGHCotherPM[i]); + hd0D0VtxTrueptTGHCotherPM = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCotherPM->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCotherPM->SetYTitle("Entries"); + flistTghCutsOther->Add(hd0D0VtxTrueptTGHCotherPM); strnamept=namehist; strnamept.Append("SBMss_pt"); @@ -2513,29 +4791,26 @@ void AliAnalysisTaskSECharmFraction::UserCreateOutputObjects() strtitlept+=fptbins[i+1]; strtitlept.Append(" [GeV/c]"); - hd0D0ptTGHCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0ptTGHCotherSB[i]->SetXTitle("Impact parameter [#mum] "); - hd0D0ptTGHCotherSB[i]->SetYTitle("Entries"); - flistTghCutsOther->Add(hd0D0ptTGHCotherSB[i]); + hd0D0ptTGHCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0ptTGHCotherSB->SetXTitle("Impact parameter [#mum] "); + hd0D0ptTGHCotherSB->SetYTitle("Entries"); + flistTghCutsOther->Add(hd0D0ptTGHCotherSB); strnamept.ReplaceAll("hd0D0","hMCd0D0"); - hMCd0D0ptTGHCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hMCd0D0ptTGHCotherSB[i]->SetXTitle("MC Impact parameter [#mum] "); - hMCd0D0ptTGHCotherSB[i]->SetYTitle("Entries"); - flistTghCutsOther->Add(hMCd0D0ptTGHCotherSB[i]); + hMCd0D0ptTGHCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hMCd0D0ptTGHCotherSB->SetXTitle("MC Impact parameter [#mum] "); + hMCd0D0ptTGHCotherSB->SetYTitle("Entries"); + flistTghCutsOther->Add(hMCd0D0ptTGHCotherSB); strnamept.ReplaceAll("hMCd0D0","hd0D0VtxTrue"); - hd0D0VtxTrueptTGHCotherSB[i] = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); - hd0D0VtxTrueptTGHCotherSB[i]->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); - hd0D0VtxTrueptTGHCotherSB[i]->SetYTitle("Entries"); - flistTghCutsOther->Add(hd0D0VtxTrueptTGHCotherSB[i]); + hd0D0VtxTrueptTGHCotherSB = new TH1F(strnamept.Data(),strtitlept.Data(),1000,-1000.,1000.); + hd0D0VtxTrueptTGHCotherSB->SetXTitle("Impact parameter w.r.t. True Vtx [#mum] "); + hd0D0VtxTrueptTGHCotherSB->SetYTitle("Entries"); + flistTghCutsOther->Add(hd0D0VtxTrueptTGHCotherSB); } - - + Printf("AFTER DATA HISTOS CREATION \n"); } - - //________________________________________________________________________ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) { @@ -2543,9 +4818,11 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) // heavy flavor candidates association to MC truth AliAODEvent *aod = dynamic_cast (InputEvent()); - - TClonesArray *arrayD0toKpi=0; - + if (!aod) { + Printf("ERROR: aod not available"); + return; + } + TClonesArray *arrayD0toKpi; if(!aod && AODEvent() && IsStandardAOD()) { // In case there is an AOD handler writing a standard AOD, use the AOD // event in memory rather than the input (ESD) event. @@ -2554,31 +4831,63 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) // have to taken from the AOD event hold by the AliAODExtension AliAODHandler* aodHandler = (AliAODHandler*) ((AliAnalysisManager::GetAnalysisManager())->GetOutputEventHandler()); + if(aodHandler->GetExtensions()) { AliAODExtension *ext = (AliAODExtension*)aodHandler->GetExtensions()->FindObject("AliAOD.VertexingHF.root"); - AliAODEvent *aodFromExt = ext->GetAOD(); - arrayD0toKpi=(TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi"); + AliAODEvent* aodFromExt = ext->GetAOD(); + if(fLikeSign){ + // load 2Prong Like Sign + arrayD0toKpi =(TClonesArray*)aodFromExt->GetList()->FindObject("LikeSign2Prong"); + if(!arrayD0toKpi) { + Printf("AliAnalysisTaskSECharmFraction::UserExec: LikeSign branch not found!\n"); + return; + } + } + else { + // load D0->Kpi candidates + arrayD0toKpi = (TClonesArray*)aodFromExt->GetList()->FindObject("D0toKpi"); + if(!arrayD0toKpi) { + Printf("AliAnalysisTaskSECharmFraction::UserExec: D0toKpi branch not found!\n"); + return; + } + } } } else { - arrayD0toKpi=(TClonesArray*)aod->GetList()->FindObject("D0toKpi"); + if(fLikeSign){ + // load 2Prong Like Sign + arrayD0toKpi =(TClonesArray*)aod->GetList()->FindObject("LikeSign2Prong"); + if(!arrayD0toKpi) { + Printf("AliAnalysisTaskSECharmFraction::UserExec: LikeSign branch not found!\n"); + return; + } + } + else { + // load D0->Kpi candidates + arrayD0toKpi = (TClonesArray*)aod->GetList()->FindObject("D0toKpi"); + if(!arrayD0toKpi) { + Printf("AliAnalysisTaskSECharmFraction::UserExec: D0toKpi branch not found!\n"); + return; + } + } } + if(!arrayD0toKpi) { - Printf("AliAnalysisTaskSECharmFraction::UserExec: D0toKpi branch not found!\n"); + printf("AliAnalysisTaskSECharmFraction::UserExec: input branch not found!\n"); return; } - - // fix for temporary bug in ESDfilter + + // fix for temporary bug in ESDfilter // the AODs with null vertex pointer didn't pass the PhysSel if(!aod->GetPrimaryVertex()) return; // AOD primary vertex AliAODVertex *vtx1 = (AliAODVertex*)aod->GetPrimaryVertex(); - TClonesArray *arrayMC=0; - AliAODMCHeader *aodmcHeader=0; + TClonesArray *arrayMC=0x0; + AliAODMCHeader *aodmcHeader=0x0; Double_t vtxTrue[3]; - + if(fReadMC){ // load MC particles arrayMC = @@ -2587,7 +4896,6 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) Printf("AliAnalysisTaskSECharmFraction::UserExec: MC particles branch not found!\n"); return; } - // load MC header aodmcHeader = (AliAODMCHeader*)aod->GetList()->FindObject(AliAODMCHeader::StdBranchName()); @@ -2595,37 +4903,50 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) Printf("AliAnalysisTaskSECharmFraction::UserExec: MC header branch not found!\n"); return; } - // MC primary vertex aodmcHeader->GetVertex(vtxTrue); - } - if (!aod) { - Printf("ERROR: aod not available"); - return; + // FILL HISTOS FOR D0 mesons, c quarks and D0 from B properties + FillHistoMCproperties(arrayMC); } - //histogram filled with 1 for every AOD fNentries->Fill(1); PostData(1,fNentries); - + //Printf("There are %d tracks in this event", aod->GetNumberOfTracks()); // Int_t nTotHF=0,nTotDstar=0,nTot3Prong=0; Int_t nTotD0toKpi=0; - Int_t okd0tight,okd0bartight,okd0loose,okd0barloose; + Int_t okd0tight,okd0bartight,okd0loose,okd0barloose,okd0tightnopid,okd0bartightnopid; Bool_t isPeakD0,isPeakD0bar,isSideBandD0,isSideBandD0bar,isSideBand; Bool_t isinacceptance; Int_t signallevel=-1; - Int_t ptbin; + Int_t ptbin,nVtx; // const Int_t nptbins=10; Double_t invMassD0,invMassD0bar,ptD0,massmumtrue; - AliAODRecoDecayHF *aodDMC=0;// to be used to create a fake true sec vertex + AliAODRecoDecayHF *aodDMC=0x0;// to be used to create a fake true sec vertex // make trkIDtoEntry register (temporary) Int_t trkIDtoEntry[100000]; + fptAll=0.; + fptAllSq=0.; + fptMax[0]=0.; + fptMax[1]=0.; + fptMax[2]=0.; for(Int_t it=0;itGetNumberOfTracks();it++) { AliAODTrack *track = aod->GetTrack(it); + fptAll+=track->Pt(); + fptAllSq+=track->Pt()*track->Pt(); + if(track->Pt()>fptMax[0]){ + fptMax[2]=fptMax[1]; + fptMax[1]=fptMax[0]; + fptMax[0]=track->Pt(); + } + else if(track->Pt()>fptMax[1]){ + fptMax[2]=fptMax[1]; + fptMax[1]=track->Pt(); + } + else if(track->Pt()>fptMax[2])fptMax[2]=track->Pt(); if(track->GetID()<0) { //printf("Track ID <0, id= %d\n",track->GetID()); return; @@ -2633,14 +4954,14 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) trkIDtoEntry[track->GetID()]=it; } - + // loop over D0->Kpi candidates Int_t nD0toKpi = arrayD0toKpi->GetEntriesFast(); nTotD0toKpi += nD0toKpi; // cout<<"Number of D0->Kpi: "<Pt(); - isinacceptance = (TMath::Abs(d->EtaProng(0))EtaProng(1))PtBin(ptD0); + Double_t relangle=d->ProngsRelAngle(0,1); + // UPV: HERE TO CHANGE WITH: + // isinacceptance = (TMath::Abs(d->EtaProng(0))EtaProng(1))AreDaughtersSelected(d); + if(!isinacceptance)signallevel=21; + if(!fCutsTight->IsInFiducialAcceptance(ptD0,d->Y(421))){ + isinacceptance=kFALSE; + signallevel=22; + } + + //################################################################################### + // + // ################ SPECIAL ADDITIONAL CUTS FOR SIGNAL SEARCH ####################### + // UPV: ITS CLUSTER SELECTION ALREADY DONE , COUNT THEM THE SAME + // + Int_t nlayers=0,nSPD=0,nSSD=0; + Bool_t spd1=kFALSE; + + for(Int_t idg=0;idgGetNDaughters();idg++){ + + AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(idg); + if(TESTBIT(dgTrack->GetITSClusterMap(),5)){ + nlayers++; + nSSD++; + } + if(TESTBIT(dgTrack->GetITSClusterMap(),4)){ + nlayers++; + nSSD++; + } + if(TESTBIT(dgTrack->GetITSClusterMap(),3))nlayers++; + if(TESTBIT(dgTrack->GetITSClusterMap(),2))nlayers++; + if(TESTBIT(dgTrack->GetITSClusterMap(),1)){ + nlayers++; + nSPD++; + } + if(TESTBIT(dgTrack->GetITSClusterMap(),0)){ + nlayers++; + nSPD++; + spd1=kTRUE; + } + } + /* + // ######## NOW SELECTION ########## + if(dgTrack->Pt()<0.5){ + // ########## k-Both selection ############## + if(nlayers<5)signallevel=25; + if(nSPD<2)signallevel=25; + } + else if(dgTrack->Pt()<1.){ + // ########## 4 its clust (1 SSD,1 SPD) && k-Any selection ############## + if(nlayers<4)signallevel=25; + if(nSSD<1)signallevel=25; + if(nSPD<1)signallevel=25; + } + else{ + // ########## 3 its clust (1 SPD, 1 SSD) && k-Any selection ########## + if(nlayers<3)signallevel=25; + if(nSSD<1)signallevel=25; + if(nSPD<1)signallevel=25; + } + } + */ + + + + + + + //########### END OF SPECIAL CUTS ###################### + // + //############################################################### + + // NOW APPLY CUTS + // Check tighter cuts w/o PID: + // + Int_t ncont=vtx1->GetNContributors(); + if(vtx1->GetNContributors()<1)signallevel=51; + Bool_t defaultNC=SpecialSelD0(d,nVtx); + Bool_t iscutusingpid=fCutsTight->GetIsUsePID(); + fCutsTight->SetUsePID(kFALSE); + Int_t isSelectedTightNoPid=fCutsTight->IsSelected(d,AliRDHFCuts::kAll,aod); + switch(isSelectedTightNoPid){ + case 0: + okd0tightnopid=kFALSE; + okd0bartightnopid=kFALSE; + break; + case 1: + okd0tightnopid=kTRUE; + okd0bartightnopid=kFALSE; + break; + case 2: + okd0tightnopid=kFALSE; + okd0bartightnopid=kTRUE; + break; + case 3: + okd0tightnopid=kTRUE; + okd0bartightnopid=kTRUE; + break; + default: + okd0tightnopid=kTRUE; + okd0bartightnopid=kTRUE; + break; + } + + if(!defaultNC){ + okd0tightnopid=kFALSE; + okd0bartightnopid=kFALSE; + } + // signallevel=fCutsTight->GetSelectionStep(); fSignalType->Fill(signallevel); - // END OF BACKGROUND TYPE SELECTION + - // NOW APPLY CUTS - //NO CUTS CASE IS FOR FREE + + // ######### SPECIAL SELECTION PID ############## + fCutsTight->SetUsePID(iscutusingpid); + Int_t isSelectedPid=fCutsTight->IsSelected(d,AliRDHFCuts::kPID,aod); + Int_t isSelectedTight=fCutsTight->CombineSelectionLevels(3,isSelectedTightNoPid,isSelectedPid); + switch(isSelectedTight){ + case 0: + okd0tight=kFALSE; + okd0bartight=kFALSE; + break; + case 1: + okd0tight=kTRUE; + okd0bartight=kFALSE; + break; + case 2: + okd0tight=kFALSE; + okd0bartight=kTRUE; + break; + case 3: + okd0tight=kTRUE; + okd0bartight=kTRUE; + break; + default: + okd0tight=kTRUE; + okd0bartight=kTRUE; + break; + } + + - // CHECK TIGHTER CUTS - ptbin=SetStandardCuts(ptD0,flargeInvMassCut); - d->SelectD0(fVHFtight->GetD0toKpiCuts(),okd0tight,okd0bartight); + + if(((isPeakD0&&okd0tight)||(isPeakD0bar&&okd0bartight))&&isinacceptance)fSignalTypeTghCuts->Fill(signallevel); // CHECK LOOSER CUTS - ptbin=SetStandardCuts(ptD0,flargeInvMassCut); - d->SelectD0(fVHFloose->GetD0toKpiCuts(),okd0loose,okd0barloose); + //ptbin=SetStandardCuts(ptD0,flargeInvMassCut); + + // d->SelectD0(fCutsLoose->GetD0toKpiCuts(),okd0loose,okd0barloose); + Int_t isSelectedLoose=fCutsLoose->IsSelected(d,AliRDHFCuts::kAll,aod); + switch(isSelectedLoose){ + case 0: + okd0loose=kFALSE; + okd0barloose=kFALSE; + break; + case 1: + okd0loose=kTRUE; + okd0barloose=kFALSE; + break; + case 2: + okd0loose=kFALSE; + okd0barloose=kTRUE; + break; + case 3: + okd0loose=kTRUE; + okd0barloose=kTRUE; + break; + default: + okd0loose=kTRUE; + okd0barloose=kTRUE; + break; + } + if(!defaultNC){ + okd0loose=kFALSE; + okd0barloose=kFALSE; + } + + + if(((isPeakD0&&okd0loose)||(isPeakD0bar&&okd0barloose))&&isinacceptance)fSignalTypeLsCuts->Fill(signallevel); + //################### FILL HISTOS ######################## //################################################################ // //######## improvement: SPEED HERE CAN BE IMPROVED: CALCULATE ONCE AND FOR ALL // CANDIDATE VARIABLES + + //NO CUTS Case: force okD0 and okD0bar = kTRUE - if(signallevel==1||signallevel==0)FillHistos(d,flistNoCutsSignal,ptbin,kTRUE,kTRUE,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); - else if(signallevel==2)FillHistos(d,flistNoCutsFromDstar,ptbin,kTRUE,kTRUE,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); - else if(signallevel==3||signallevel==4)FillHistos(d,flistNoCutsFromB,ptbin,kTRUE,kTRUE,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); - else if(signallevel==-1||signallevel==7||signallevel==8||signallevel==10||signallevel==9)FillHistos(d,flistNoCutsBack,ptbin,kTRUE,kTRUE,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); - else if(signallevel==5||signallevel==6)FillHistos(d,flistNoCutsOther,ptbin,kTRUE,kTRUE,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); + // special cuts are applied also in the "NO Cuts" case + // + // + // SPECIAL modification: + // IMPORTANT!!!!!! ONLY FOR TEMPORARY CONVENIENCE + // IF fusePID is kTRUE, NO CUTS BECOMES NO PID case with tight cuts (fill signal histos when 30<=signallevel<40 )!!!!!!!!!! + if(!fusePID){ + okd0tightnopid=defaultNC; + okd0bartightnopid=defaultNC; + } + // ############ MISALIGN HERE: TEMPORARY SOLUTION ########## + //d->Misalign("full14"); + if(signallevel==1||signallevel==0)FillHistos(d,flistNoCutsSignal,ptbin,okd0tightnopid,okd0bartightnopid,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); // else if(fusePID&&signallevel>=30&&signallevel<40)FillHistos(d,flistNoCutsSignal,ptbin,okd0tightnopid,okd0bartightnopid,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue);// OLD LINE, COULD BE REMOVED + else if(signallevel==2)FillHistos(d,flistNoCutsFromDstar,ptbin,okd0tightnopid,okd0bartightnopid,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); + else if(signallevel==3||signallevel==4)FillHistos(d,flistNoCutsFromB,ptbin,okd0tightnopid,okd0bartightnopid,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); + else if(signallevel==-1||signallevel==7||signallevel==8||signallevel==10||signallevel==9)FillHistos(d,flistNoCutsBack,ptbin,okd0tightnopid,okd0bartightnopid,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); + else if(signallevel==5||signallevel==6)FillHistos(d,flistNoCutsOther,ptbin,okd0tightnopid,okd0bartightnopid,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); + + //LOOSE CUTS Case if(signallevel==1||signallevel==0)FillHistos(d,flistLsCutsSignal,ptbin,okd0loose,okd0barloose,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); else if(signallevel==2)FillHistos(d,flistLsCutsFromDstar,ptbin,okd0loose,okd0barloose,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); @@ -2726,9 +5262,19 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) else if(signallevel==5||signallevel==6)FillHistos(d,flistTghCutsOther,ptbin,okd0tight,okd0bartight,invMassD0,invMassD0bar,isPeakD0,isPeakD0bar,isSideBand,massmumtrue,aodDMC,vtxTrue); - if(aodDMC){ + + + // ######## PRINTING INFO FOR D0-like candidate + + if(nSPD==2&&ptD0>2.){ + if((okd0tight&&TMath::Abs(invMassD0-1.864)<0.01)||(okd0bartight&&TMath::Abs(invMassD0bar-1.864)<0.01)){ + printf("INFO FOR DRAWING: \n pt: %f \n Rapidity: %f \n Period Number: %d \n Run Number: %d \n BunchCrossNumb: %d \n OrbitNumber: %d \n",ptD0,d->Y(421),aod->GetPeriodNumber(),aod->GetRunNumber(),aod->GetBunchCrossNumber(),aod->GetOrbitNumber()); +printf("PrimVtx NContributors: %d \n Prongs Rel Angle: %f \n \n",ncont,relangle); + } + } + if(aodDMC!=0x0){ delete aodDMC; - aodDMC=0; + aodDMC=0x0; } if(unsetvtx) d->UnsetOwnPrimaryVtx(); @@ -2741,27 +5287,157 @@ void AliAnalysisTaskSECharmFraction::UserExec(Option_t */*option*/) PostData(2,fSignalType); PostData(3,fSignalTypeLsCuts); PostData(4,fSignalTypeTghCuts); - PostData(5,flistNoCutsSignal); - PostData(6,flistNoCutsBack); - PostData(7,flistNoCutsFromB); - PostData(8,flistNoCutsFromDstar); - PostData(9,flistNoCutsOther); - PostData(10,flistLsCutsSignal); - PostData(11,flistLsCutsBack); - PostData(12,flistLsCutsFromB); - PostData(13,flistLsCutsFromDstar); - PostData(14,flistLsCutsOther); - PostData(15,flistTghCutsSignal); - PostData(16,flistTghCutsBack); - PostData(17,flistTghCutsFromB); - PostData(18,flistTghCutsFromDstar); - PostData(19,flistTghCutsOther); + PostData(5,flistMCproperties); + PostData(6,flistNoCutsSignal); + PostData(7,flistNoCutsBack); + PostData(8,flistNoCutsFromB); + PostData(9,flistNoCutsFromDstar); + PostData(10,flistNoCutsOther); + PostData(11,flistLsCutsSignal); + PostData(12,flistLsCutsBack); + PostData(13,flistLsCutsFromB); + PostData(14,flistLsCutsFromDstar); + PostData(15,flistLsCutsOther); + PostData(16,flistTghCutsSignal); + PostData(17,flistTghCutsBack); + PostData(18,flistTghCutsFromB); + PostData(19,flistTghCutsFromDstar); + PostData(20,flistTghCutsOther); return; } +//_________________________________________ +Int_t AliAnalysisTaskSECharmFraction::SetStandardCuts(Float_t *&ptbinlimits){// SET CUTS USED BEFORE UP TO JULY 2010; (THEY CHANGED LATER) + // DOES NOT SET NPTBINS AND PT BIN LIMITS IN *this object: + // it returns nptbins and set bin limits in ptbinlimits pointer + + if(fCutsTight){ + delete fCutsTight;fCutsTight=NULL; + } + if(fCutsLoose){ + delete fCutsLoose;fCutsLoose=NULL; + } + + fCutsTight = new AliRDHFCutsD0toKpi(); + fCutsTight->SetName("D0toKpiCutsStandard"); + fCutsTight->SetTitle("Standard Cuts for D0 analysis"); + + fCutsLoose = new AliRDHFCutsD0toKpi(); + fCutsLoose->SetName("D0toKpiCutsLoose"); + fCutsLoose->SetTitle("Loose Cuts for D0 analysis"); + + // EVENT CUTS + fCutsTight->SetMinVtxContr(4); + fCutsLoose->SetMinVtxContr(4); + + // TRACKS ON SINGLE TRACKS + AliESDtrackCuts *esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts","default"); + esdTrackCuts->SetRequireSigmaToVertex(kFALSE); + esdTrackCuts->SetRequireTPCRefit(kTRUE); + esdTrackCuts->SetRequireITSRefit(kTRUE); + esdTrackCuts->SetMinNClustersITS(4); + esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD,AliESDtrackCuts::kAny); + esdTrackCuts->SetMinDCAToVertexXY(0.); + esdTrackCuts->SetEtaRange(-0.8,0.8); + esdTrackCuts->SetPtRange(0.3,1.e10); + + fCutsTight->AddTrackCuts(esdTrackCuts); + + + // const Double_t ptmin = 0.1; + const Double_t ptmax = 9999.; + const Int_t nptbins = 7; + const Int_t nvars=9; + Float_t *ptbins=new Float_t[nptbins+1]; + ptbins[0]=0.; + ptbins[1]=1.; + ptbins[2]=2.; + ptbins[3]=3.; + ptbins[4]=5.; + ptbins[5]=8.; + ptbins[6]=12.; + ptbins[7]=ptmax; + + fCutsTight->SetPtBins(nptbins+1,ptbins); + fCutsLoose->SetPtBins(nptbins+1,ptbins); + + /* Float_t cutsArrayD0toKpiStand_1[9]={0.200,300.*1E-4,0.8,0.3,0.3,1000.*1E-4,1000.*1E-4,-35000.*1E-8,0.7}; // pt<1 + Float_t cutsArrayD0toKpiStand_2[9]={0.200,200.*1E-4,0.8,0.4,0.4,1000.*1E-4,1000.*1E-4,-30000.*1E-8,0.8}; // 1<=pt<2 + Float_t cutsArrayD0toKpiStand_3[9]={0.200,200.*1E-4,0.8,0.7,0.7,1000.*1E-4,1000.*1E-4,-26000.*1E-8,0.94}; // 2<=pt<3 + Float_t cutsArrayD0toKpiStand_4[9]={0.200,200.*1E-4,0.8,0.7,0.7,1000.*1E-4,1000.*1E-4,-15000.*1E-8,0.88}; // 3<=pt<5 + Float_t cutsArrayD0toKpiStand_5[9]={0.200,150.*1E-4,0.8,0.7,0.7,1000.*1E-4,1000.*1E-4,-10000.*1E-8,0.9}; // 5<=pt<8 + Float_t cutsArrayD0toKpiStand_6[9]={0.200,150.*1E-4,0.8,0.7,0.7,1000.*1E-4,1000.*1E-4,-10000.*1E-8,0.9}; // 812 + */ + + + + Float_t cutsMatrixD0toKpiStand[nptbins][nvars]={{0.200,300.*1E-4,0.8,0.3,0.3,1000.*1E-4,1000.*1E-4,-40000.*1E-8,0.7},/* pt<1*/ + {0.200,200.*1E-4,0.8,0.4,0.4,1000.*1E-4,1000.*1E-4,-32000.*1E-8,0.8},/* 112 */ + + Float_t cutsMatrixD0toKpiLoose[nptbins][nvars]={{0.200,300.*1E-4,0.8,0.3,0.3,1000.*1E-4,1000.*1E-4,-35000.*1E-8,0.75},/* pt<1*/ + {0.200,200.*1E-4,0.8,0.4,0.4,1000.*1E-4,1000.*1E-4,-28000.*1E-8,0.75},/* 112 */ + + /* for (Int_t ibin=0;ibin<=nptbins;ibin++){ + for (Int_t ivar = 0; ivarSetCuts(nvars,nptbins,cutsMatrixTransposeStand); + fCutsLoose->SetCuts(nvars,nptbins,cutsMatrixTransposeLoose); + fCutsTight->SetUseSpecialCuts(kTRUE); + fCutsLoose->SetUseSpecialCuts(kTRUE); + fCutsTight->SetRemoveDaughtersFromPrim(kTRUE); + fCutsLoose->SetRemoveDaughtersFromPrim(kTRUE); + fCutsTight->SetUsePID(kTRUE); + fCutsLoose->SetUsePID(kTRUE); + + Printf("STANDARD CUTS OBJECT : \n"); + fCutsTight->PrintAll(); + Printf("SECOND CUTS OBJECT : \n"); + fCutsLoose->PrintAll(); + + ptbinlimits=ptbins;//new Float_t[nptbins+1]; //ptbins; + /* new Float[nptbins]; + for(Int_t ib=0;ib0. && pt<=1.) { - ptbin=0; - fVHFtight->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.0002,0.5); - fVHFloose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.00025,0.7); - } - - if(pt>1. && pt<=3.) { + if(pt>0. && pt<=1.) { + ptbin=0; + fCutsTight->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.0002,0.5); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.00025,0.7); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.3,0.3,1.,1.,-0.0002,0.7); + } + if(pt>1. && pt<=2.) { ptbin=1; - fVHFtight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.05,0.05,-0.0002,0.6); - fVHFloose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsTight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.05,0.05,-0.0002,0.6); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.3,0.3,1.,1.,-0.0001,0.7); //printf("I'm in the bin %d\n",ptbin); } - - if(pt>3. && pt<=5.){ + if(pt>2. && pt<=3.) { ptbin=2; - fVHFtight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.0001,0.8); - fVHFloose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.8); + fCutsTight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.05,0.05,-0.0002,0.6); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.3,0.3,1.,1.,-0.0001,0.7); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>3. && pt<=5.){ + ptbin=3; + fCutsTight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.0001,0.8); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.4,0.4,1.,1.,-0.0001,0.75); //printf("I'm in the bin %d\n",ptbin); } if(pt>5.){ - ptbin=3; - fVHFtight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00005,0.8); - fVHFloose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.9); + ptbin=4; + fCutsTight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00005,0.8); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.9); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.5,0.5,1.,1.,-0.00005,0.75); + }//if(pt>5) + return ptbin; + //############################################################################ + */ + + + + /* //####################################################################### + //################# VARY CUTS for d0xd0 STUDY ########################## + +if(pt>0. && pt<=1.) { + ptbin=0; + fCutsTight->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.0002,0.5); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.00025,0.7); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.3,0.3,1.,1.,-0.0002,0.7); + } + if(pt>1. && pt<=2.) { + ptbin=1; + fCutsTight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.05,0.05,0.2,0.6); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.3,0.3,1.,1.,-0.0001,0.1); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>2. && pt<=3.) { + ptbin=2; + fCutsTight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.05,0.05,0.2,0.6); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.3,0.3,1.,1.,-0.0001,0.1); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>3. && pt<=5.){ + ptbin=3; + fCutsTight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,0.2,0.8); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.3,0.4,0.4,1.,1.,-0.0001,0.1); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>5.){ + ptbin=4; + fCutsTight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,0.2,0.8); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.9); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.5,0.5,1.,1.,-0.00005,0.1); + }//if(pt>5) + return ptbin; + // ################################################################# + */ + + //########################################################################## + //################## CUTS with d0xd0 cut released ######################### + //### and TGHC cuts d0K and d0Pi to 0.1 instead of 0.05 + //### USED FOR PHDthesis + //########################################################################## + + /* if(pt>0. && pt<=1.) { + ptbin=0; + fCutsTight->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.1,0.1,-0.000,0.5); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.00025,0.7); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.3,0.3,1.,1.,-0.000,0.7); + } + if(pt>1. && pt<=2.) { + ptbin=1; + fCutsTight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.1,0.1,-0.000,0.6); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.4,0.4,1.,1.,-0.0000,0.7); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>2. && pt<=3.) { + ptbin=2; + fCutsTight->SetD0toKpiCuts(invMassCut,0.03,0.8,0.6,0.6,0.1,0.1,-0.000,0.6); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.4,0.4,1.,1.,-0.000,0.7); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>3. && pt<=5.){ + ptbin=3; + fCutsTight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.000,0.8); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.8); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.5,0.5,1.,1.,-0.000,0.75); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>5.){ + ptbin=4; + fCutsTight->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.0000,0.8); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.9); + fCutsLoose->SetD0toKpiCuts(invMassCut,0.03,0.8,0.5,0.5,1.,1.,-0.0000,0.75); + }//if(pt>5) + return ptbin; + */ + + + + + //########## LOOKING FOR SIGNAL ##################### + /* + if(pt>0. && pt<=1.) { + ptbin=0; + fCutsTight->SetD0toKpiCuts(5*invMassCut,0.03,0.8,0.3,0.3,0.1,0.1,-0.00035,0.7); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.04,0.8,0.5,0.5,0.05,0.05,-0.00025,0.7); + fCutsLoose->SetD0toKpiCuts(5*invMassCut,0.04,0.8,0.3,0.3,0.1,0.1,-0.00025,0.7); + } + if(pt>1. && pt<=2.) { + ptbin=1; + fCutsTight->SetD0toKpiCuts(5*invMassCut,0.02,0.8,0.4,0.4,0.1,0.1,-0.00035,0.8); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(5*invMassCut,0.03,0.8,0.3,0.3,0.1,0.1,-0.0025,0.75); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>2. && pt<=3.) { + ptbin=2; + fCutsTight->SetD0toKpiCuts(5*invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.00026,0.94); + //fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,1,1,-0.00025,0.8); + fCutsLoose->SetD0toKpiCuts(5*invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.0002,0.92); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>3. && pt<=5.){ + ptbin=3; + fCutsTight->SetD0toKpiCuts(5*invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.00015,0.88); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.8); + fCutsLoose->SetD0toKpiCuts(5*invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.00015,0.9); + //printf("I'm in the bin %d\n",ptbin); + } + if(pt>5.&& pt<=8.){ + ptbin=4; + fCutsTight->SetD0toKpiCuts(5*invMassCut,0.015,0.8,0.7,0.7,0.1,0.1,-0.0001,0.9); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.9); + fCutsLoose->SetD0toKpiCuts(5*invMassCut,0.02,0.8,0.7,0.7,0.1,0.1,-0.0000,0.88); + }//if(pt>5) + if(pt>8.&&pt<=12.){ + ptbin=5; + fCutsTight->SetD0toKpiCuts(5*invMassCut,0.015,0.8,0.7,0.7,0.1,0.1,-0.0001,0.9); + // fCutsLoose->SetD0toKpiCuts(invMassCut,0.02,0.8,0.7,0.7,0.05,0.05,-0.00015,0.9); + fCutsLoose->SetD0toKpiCuts(5*invMassCut,0.015,0.8,0.7,0.7,0.1,0.1,-0.0005,0.88); }//if(pt>5) + return ptbin; + */ + printf("AliAnalysisTaskSECharmFraction::Obsolete method! Parameters pt=%f,invmasscut=%f not used \n",pt,invMassCut); + return ptbin; + } //__________________________________________________________ @@ -2840,20 +5669,20 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::GetD0toKPiSignalType(const Al // IF (!AND ONLY IF) THE TWO DAUGHTERS COME FROM A COMMONE MOTHER A FAKE TRUE SECONDARY VERTEX IS CONSTRUCTED (aodDMC) // // THE FOLLOWING SCHEME IS ADOPTED: signaltype is set to - // 1:signal (D0 prompt); 2: signal D0 from Dstar; 3: D0 fromB 4: D0 from Dstar fromB - // then background categories: -1: one or both daughters is a fake track - // 5: both daughters come from a D meson != D0 - // 6: both daughters come from a D0->4prongs - // 7: both daughetrs are primaries - // 8: generic background (can include one of the previous if desired) - // 9: daughters out of acceptance - // 10: pathologic cases (not clear) - // 11: end of the method without output - // 12: different result than MatchToMC method - - AliAODMCParticle *mum1=0; - AliAODMCParticle *b1=0,*b2=0; - AliAODMCParticle *grandmoth1=0; + // 1:signal (D0 prompt); 2: signal D0 from Dstar; 3: D0 fromB 4: D0 from Dstar fromB + // then background categories: -1: one or both daughters is a fake track + // 5: both daughters come from a D meson != D0 + // 6: both daughters come from a D0->4prongs + // 7: both daughetrs are primaries + // 8: generic background (can include one of the previous if desired) + // 9: daughters out of acceptance + // 10: pathologic cases (not clear) + // 11: end of the method without output + // 12: different result than MatchToMC method + + AliAODMCParticle *mum1=0x0; + AliAODMCParticle *b1=0x0,*b2=0x0; + AliAODMCParticle *grandmoth1=0x0; massMumTrue=-1; Int_t pdgmum,dglabels[2],matchtoMC; @@ -2861,8 +5690,8 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::GetD0toKPiSignalType(const Al // get daughter AOD tracks AliAODTrack *trk0 = (AliAODTrack*)d->GetDaughter(0); AliAODTrack *trk1 = (AliAODTrack*)d->GetDaughter(1); - AliAODRecoDecayHF *aodDMC=0; - if(!trk0 || !trk1){ + AliAODRecoDecayHF *aodDMC=0x0; + if(trk0==0x0||trk1==0x0){ AliDebug(2,"Delete tracks I AM \n"); signaltype=-1; @@ -2871,7 +5700,7 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::GetD0toKPiSignalType(const Al } dglabels[0]=trk0->GetLabel(); dglabels[1]=trk1->GetLabel(); - if(dglabels[0]<0 || dglabels[1]<0){ + if(dglabels[0]<0||dglabels[1]<0){ AliDebug(2,"HERE I AM \n"); //fake tracks @@ -2884,17 +5713,13 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::GetD0toKPiSignalType(const Al b1=(AliAODMCParticle*)arrayMC->At(trk0->GetLabel()); b2=(AliAODMCParticle*)arrayMC->At(trk1->GetLabel()); - - if(!b1 || !b2) { - //Tracks with no mother ????? FAKE DECAY VERTEX - + if(!b1||!b2){ + //Tracks with no mother ??? FAKE DECAY VERTEX signaltype=10; return aodDMC; } - if(b1->GetMother()<0||b2->GetMother()<0){ - //Tracks with no mother ????? FAKE DECAY VERTEX - + //Tracks with no mother ??? FAKE DECAY VERTEX signaltype=10; return aodDMC; } @@ -2915,7 +5740,7 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::GetD0toKPiSignalType(const Al matchtoMC=d->MatchToMC(421,arrayMC,2,pdgdaughters); aodDMC=ConstructFakeTrueSecVtx(b1,b2,mum1,primaryVtx); - if(aodDMC){ + if(aodDMC==0x0){ signaltype=10; return aodDMC; } @@ -3028,15 +5853,15 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::GetD0toKPiSignalType(const Al AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::ConstructFakeTrueSecVtx(const AliAODMCParticle *b1, const AliAODMCParticle *b2, const AliAODMCParticle *mum,Double_t *primaryVtxTrue){ // CONSTRUCT A FAKE TRUE SECONDARY VERTEX (aodDMC) //!!!NOTE THAT ONLY ONE MOTHER IS CONSIDERED: THE METHOD REQUIRES THE DAUGHTERS COME FROM THE SAME MOTHER !! - if(!b1 || !b2)return 0; - if(!mum)return 0; + if(b1==0x0||b2==0x0)return 0x0; + if(mum==0x0)return 0x0; Double_t pD[3],xD[3],pXtrTrue[2],pYtrTrue[2],pZtrTrue[2],xtr1[3],xtr2[3]; Int_t charge[2]={0,0}; if(b1->Charge()==-1)charge[0]=1; else { if(b2->Charge()==-1){ //printf("Same charges for prongs \n"); - return 0; + if(!fLikeSign)return 0x0; } charge[1]=1; } @@ -3045,7 +5870,7 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::ConstructFakeTrueSecVtx(const pYtrTrue[charge[0]]=b1->Py(); pZtrTrue[charge[0]]=b1->Pz(); if(!b1->XvYvZv(xtr1)){ - return 0; + return 0x0; } pXtrTrue[charge[1]]=b2->Px(); @@ -3054,11 +5879,11 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::ConstructFakeTrueSecVtx(const if(!mum->PxPyPz(pD)){ //printf("!D from B:Get momentum failed \n"); - return 0; + return 0x0; } if(!mum->XvYvZv(xD)){ //printf("!D from B:Get position failed \n"); - return 0; + return 0x0; } /* ############ THIS HAPPENS FROM TIME TO TIME: NUMERIC PROBLEM KNOWN ################# if(pXtrTrue[0]+pXtrTrue[1]!=pD[0]){ @@ -3066,7 +5891,7 @@ AliAODRecoDecayHF* AliAnalysisTaskSECharmFraction::ConstructFakeTrueSecVtx(const if(!b2->XvYvZv(xtr2)){ - return 0; + return 0x0; } Double_t d0dummy[2]={0.,0.};//TEMPORARY : dummy d0 for AliAODRecoDeay constructor AliAODRecoDecayHF* aodDMC=new AliAODRecoDecayHF(primaryVtxTrue,xD,2,0,pXtrTrue,pYtrTrue,pZtrTrue,d0dummy); @@ -3089,7 +5914,33 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi if((!okD0)&&(!okD0bar))return kTRUE; + if(ptbin==-1)return kTRUE; + // flistNoCutsSignal->Add(hptD0NCsign); + // flistNoCutsSignal->Add(hptD0VsMaxPtNCsign); + // flistNoCutsSignal->Add(hptD0PTallsqrtNCsign); + // flistNoCutsSignal->Add(hptD0PTallNCsign); + + // %%%%%% TO BE DONE + // flistNoCutsSignal->Add(hptD0vsptBNCsign); + // flistNoCutsSignal->Add(hpD0vspBNCsign); + //flistNoCutsSignal->Add(hptD0vsptcquarkNCsign); + //flistNoCutsSignal->Add(hpD0vspcquarkNCsign); + // %%%%%%%%%%%%%%%%%%%%%%%%%%%% + // %%%%%%%%%%%%%%%%%%%%%%%%%%%%% + // DONE + //hd0zD0ptLSCsign_pt + //hInvMassLSCsign_pt + //hetaLSCsign_pt + // + // %%% TO BE DONE %% + //hCosPDPBLSCsign_pt + //hCosPcPDLSCsign_pt + + + + + // ######### Get Standard label for hist in tlist ############### TString namehist=list->GetName(),str; namehist.ReplaceAll("list",""); @@ -3121,6 +5972,12 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi str.Append(namehist.Data()); ((TH1F*)list->FindObject(str.Data()))->Fill(TMath::ATan2(d->GetSecVtxY()*10000.,d->GetSecVtxX()*10000.)*TMath::RadToDeg()); + + str="hd0singlTrack"; + str.Append(namehist.Data()); + ((TH1F*)list->FindObject(str.Data()))->Fill(d->Getd0Prong(0)*10000.); + ((TH1F*)list->FindObject(str.Data()))->Fill(d->Getd0Prong(1)*10000.); + str="hCPta"; str.Append(namehist.Data()); ((TH1F*)list->FindObject(str.Data()))->Fill(d->CosPointingAngle()); @@ -3128,8 +5985,85 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi str="hd0xd0"; str.Append(namehist.Data()); ((TH1F*)list->FindObject(str.Data()))->Fill(1e8*d->Prodd0d0()); - } - + + //%%%%%%%% NEW HISTO %%%%%%%%%% + str="hdca"; + str.Append(namehist.Data()); + ((TH1F*)list->FindObject(str.Data()))->Fill(1e4*d->GetDCA()); + + str="hcosthetastar"; + str.Append(namehist.Data()); + if(okD0)((TH1F*)list->FindObject(str.Data()))->Fill(d->CosThetaStarD0()); + if(okD0bar)((TH1F*)list->FindObject(str.Data()))->Fill(d->CosThetaStarD0bar()); + + str="hptD0"; + str.Append(namehist.Data()); + ((TH1F*)list->FindObject(str.Data()))->Fill(d->Pt()); + + str="hptD0VsMaxPt"; + str.Append(namehist.Data()); + Int_t pr=0; + if(d->PtProng(1)>d->PtProng(0))pr=1; + if(d->PtProng(pr)FindObject(str.Data()))->Fill(d->Pt()-fptMax[0]); + else if(d->PtProng(TMath::Abs(pr-1))FindObject(str.Data()))->Fill(d->Pt()-fptMax[1]); + else ((TH1F*)list->FindObject(str.Data()))->Fill(d->Pt()-fptMax[2]); + + + str="hptD0PTallsqrt"; + str.Append(namehist.Data()); + Double_t sumsqrpt=fptAllSq-d->PtProng(1)*d->PtProng(1)-d->PtProng(0)*d->PtProng(0); + if(sumsqrpt>0.)((TH1F*)list->FindObject(str.Data()))->Fill(d->Pt(),TMath::Sqrt(sumsqrpt)); + + str="hptD0PTall"; + str.Append(namehist.Data()); + ((TH1F*)list->FindObject(str.Data()))->Fill(d->Pt(),fptAll-d->PtProng(1)-d->PtProng(0)); + + + str="hd0zD0pt"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + if(d->GetPrimaryVtx()!=0x0)((TH1F*)list->FindObject(str.Data()))->Fill(1e4*(d->Zv()-d->GetPrimaryVtx()->GetZ())); + + str="heta"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + ((TH1F*)list->FindObject(str.Data()))->Fill(d->Eta()); + + // OTHER NEW ADDITIONAL HISTOS + + str="hd0xd0"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + //printf("Hist name: %s \n",str.Data()); + ((TH1F*)list->FindObject(str.Data()))->Fill(1e8*d->Prodd0d0()); + + + str="hd0D0VSd0xd0"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + //printf("Hist name: %s \n",str.Data()); + ((TH2F*)list->FindObject(str.Data()))->Fill(1e8*d->Prodd0d0(),d->ImpParXY()*10000.); + + + str="hangletracksVSd0xd0"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + //printf("Hist name: %s \n",str.Data()); + ((TH2F*)list->FindObject(str.Data()))->Fill(1e8*d->Prodd0d0(),d->ProngsRelAngle(0,1)); + + str="hangletracksVSd0D0"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + // printf("Hist name: %s \n",str.Data()); + ((TH2F*)list->FindObject(str.Data()))->Fill(d->ImpParXY()*10000.,d->ProngsRelAngle(0,1)); + // #################################################### + } // ######### Invariant mass histos ################# str="hMass"; @@ -3145,6 +6079,34 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi if(isPeakD0&&okD0)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0); if(isPeakD0bar&&okD0bar)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0bar); } + // The Following is a NEW HISTO + str="hInvMass"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + if(okD0)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0); + if(okD0bar)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0bar); + + + str="hInvMassPt"; + str.Append(namehist.Data()); + if(okD0)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0,d->Pt()); + if(okD0bar)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0bar,d->Pt()); + + /* if(isPeakD0||isPeakD0bar){ + str="hMass"; + str.Append(namehist.Data()); + str.Append("PM"); + if(isPeakD0&&okD0)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0); + if(isPeakD0bar&&okD0bar)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0bar); + // The Following is a NEW HISTO + str="hInvMass"; + str.Append(namehist.Data()); + str.Append("_pt"); + str+=ptbin; + if(isPeakD0&&okD0)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0); + if(isPeakD0bar&&okD0bar)((TH1F*)list->FindObject(str.Data()))->Fill(invMassD0bar); + }*/ if(isSideBand){ str="hMass"; str.Append(namehist.Data()); @@ -3186,7 +6148,7 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi ((TH1F*)list->FindObject(str.Data()))->Fill(d->ImpParXY()*10000.); - if(fReadMC && vtxTrue){ + if(fReadMC&&vtxTrue){ str="hd0D0VtxTrue"; str.Append(namehist.Data()); str.Append("PM"); @@ -3199,7 +6161,7 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi ((TH1F*)list->FindObject(str.Data()))->Fill(d->AliAODRecoDecay::ImpParXY(vtxTrue)*10000.); } - if(fReadMC && aodDMC){ + if(fReadMC&&aodDMC!=0x0){ aodDMC->Print(""); aodDMC->ImpParXY(); aodDMC->Print(""); @@ -3243,7 +6205,7 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi } - if(fReadMC && aodDMC){ + if(fReadMC&&aodDMC!=0x0){ str="hMCd0D0"; str.Append(namehist.Data()); str.Append("SB"); @@ -3262,22 +6224,207 @@ Bool_t AliAnalysisTaskSECharmFraction::FillHistos(AliAODRecoDecayHF2Prong *d,TLi } -void AliAnalysisTaskSECharmFraction::SetNPtBins(Int_t nbins,const Double_t *ptbins){ - // SET THE PT BINS - if(fptbins)delete fptbins; - fnbins=nbins;fptbins=new Double_t[fnbins]; - memcpy(fptbins,ptbins,fnbins*sizeof(Double_t)); + void AliAnalysisTaskSECharmFraction::FillHistoMCproperties(TClonesArray *arrayMC){ + //############################################################# + // HERE LOOK AT global properties of D0 mesons, c quarks and B + // + //############################################################# + Double_t pxyzMum[3],pxyzDaught[3],cosOpenAngle=-1.1,ptmum,ptdaught; + Int_t ncdaught=0,cquarksMC=0,nD0all=0,nD0FromB=0,nBdaught=0,nD0bquark=0,nD0bMeson=0,nD0bBaryon=0; + for (Int_t iPart=0; iPartGetEntriesFast(); iPart++) { + AliAODMCParticle* mcPart = dynamic_cast(arrayMC->At(iPart)); + if (!mcPart) { + AliWarning("Particle not found in tree, skipping"); + continue; + } + if (TMath::Abs(mcPart->GetPdgCode()) == 4){ + cquarksMC++; + mcPart->PxPyPz(pxyzMum); + ptmum=mcPart->Pt(); + + ((TH1F*)flistMCproperties->FindObject("hMCcquarkAllPt"))->Fill(ptmum); + ((TH1F*)flistMCproperties->FindObject("hMCcquarkAllEta"))->Fill(mcPart->Eta()); + ((TH1F*)flistMCproperties->FindObject("hMCcquarkAllEnergy"))->Fill(mcPart->E()); + //NOW LOOK FOR A D0 among cquark daughters + ncdaught=mcPart->GetDaughter(1)-mcPart->GetDaughter(0)+1; + ((TH1F*)flistMCproperties->FindObject("hMCcquarkNdaught"))->Fill(ncdaught); + if(ncdaught>1){ + for(Int_t iDaught=mcPart->GetDaughter(0);iDaughtGetDaughter(1);iDaught++){ + AliAODMCParticle* mcPartD0 = dynamic_cast(arrayMC->At(iDaught)); + if(TMath::Abs(mcPartD0->GetPdgCode()) == 421){ + // a D0 coming from a c quark + mcPartD0->PxPyPz(pxyzDaught); + ptdaught=mcPartD0->Pt(); + ((TH1F*)flistMCproperties->FindObject("hMCD0fromcPt"))->Fill(ptdaught); + ((TH1F*)flistMCproperties->FindObject("hMCD0fromcEta"))->Fill(mcPartD0->Eta()); + ((TH1F*)flistMCproperties->FindObject("hMCD0fromcEnergy"))->Fill(mcPartD0->E()); + // ############################################################################################## + // Compare D0 momentum and c quarks: + // NB: here ALL D0 are considered, also those not decaying in KPi !!! + // ############################################################################################## + ((TH2F*)flistMCproperties->FindObject("hMCD0VscquarkPt"))->Fill(mcPart->Pt(),mcPartD0->Pt()); + ((TH2F*)flistMCproperties->FindObject("hMCD0VscquarkEnergy"))->Fill(mcPart->E(),mcPartD0->E()); + ((TH1F*)flistMCproperties->FindObject("hMCD0deltacquarkEnergy"))->Fill(mcPartD0->E()/mcPart->E()); + ((TH1F*)flistMCproperties->FindObject("hMCD0EnergyVsAvcquarkDaughtEn"))->Fill((mcPartD0->E()-(mcPart->E()/ncdaught))/mcPart->E()); + //calculate open angle + if((pxyzMum[0]!=0.||pxyzMum[1]!=0.||pxyzMum[2]!=0.)&&(pxyzDaught[0]!=0.||pxyzDaught[1]!=0.||pxyzDaught[2]!=0.))cosOpenAngle=(pxyzDaught[0]*pxyzMum[0]+pxyzDaught[1]*pxyzMum[1]+pxyzDaught[2]*pxyzMum[2])/(TMath::Sqrt(pxyzDaught[0]*pxyzDaught[0]+pxyzDaught[1]*pxyzDaught[1]+pxyzDaught[2]*pxyzDaught[2])*TMath::Sqrt(pxyzDaught[0]*pxyzDaught[0]+pxyzDaught[1]*pxyzDaught[1]+pxyzDaught[2]*pxyzDaught[2])); + ((TH1F*)flistMCproperties->FindObject("hMCD0cquarkAngle"))->Fill(cosOpenAngle); + ((TH2F*)flistMCproperties->FindObject("hMCD0cquarkAngleEnergy"))->Fill(mcPart->E(),cosOpenAngle); + } + } + } + } + + // NOW LOOK FOR D0 not coming from cquarks + if (TMath::Abs(mcPart->GetPdgCode()) == 421){ + nD0all++; + if(mcPart->GetMother()<0)continue; + AliAODMCParticle* mcD0Parent = dynamic_cast(arrayMC->At(mcPart->GetMother())); + Bool_t notfound=kFALSE,bMeson=kFALSE,bBaryon=kFALSE; + //CheckOrigin + while(TMath::Abs(mcD0Parent->GetPdgCode())!=4&&TMath::Abs(mcD0Parent->GetPdgCode())!=5){ + if(500GetPdgCode())%10000&&TMath::Abs(mcD0Parent->GetPdgCode())<600){ + bMeson=kTRUE; + break; + } + else if (5000GetPdgCode())&&TMath::Abs(mcD0Parent->GetPdgCode())<6000){ + bBaryon=kTRUE; + break; + } + if(mcD0Parent->GetMother()<0){ + notfound=kTRUE; + break; + } + mcD0Parent=dynamic_cast(arrayMC->At(mcD0Parent->GetMother())); + } + if(notfound)continue; + if(TMath::Abs(mcD0Parent->GetPdgCode())==4)continue;//D0 from c quarks already counted + ((TH1F*)flistMCproperties->FindObject("hMCfromBpdgB"))->Fill(TMath::Abs(mcD0Parent->GetPdgCode())); + if(bBaryon)nD0bBaryon++; + else if(bMeson)nD0bMeson++; + else nD0bquark++; + nD0FromB++; + mcD0Parent->PxPyPz(pxyzMum); + ptmum=mcD0Parent->Pt(); + ((TH1F*)flistMCproperties->FindObject("hMCBhadrPt"))->Fill(ptmum); + ((TH1F*)flistMCproperties->FindObject("hMCBhadrEta"))->Fill(mcD0Parent->Eta()); + ((TH1F*)flistMCproperties->FindObject("hMCBhadrEnergy"))->Fill(mcD0Parent->E()); + + nBdaught=mcD0Parent->GetDaughter(1)-mcD0Parent->GetDaughter(0)+1; + ((TH1F*)flistMCproperties->FindObject("hMCBhadrNdaught"))->Fill(nBdaught); + + + // Now take properties of this D0 coming from a B + mcPart->PxPyPz(pxyzDaught); + ptdaught=mcPart->Pt(); + ((TH1F*)flistMCproperties->FindObject("hMCD0fromBPt"))->Fill(ptdaught); + ((TH1F*)flistMCproperties->FindObject("hMCD0fromBEta"))->Fill(mcPart->Eta()); + ((TH1F*)flistMCproperties->FindObject("hMCD0fromBEnergy"))->Fill(mcPart->E()); + // ############################################################################################## + // Compare D0 momentum and b hadron: + // NB: here ALL D0 are considered, also those not decaying in KPi !!! + // ############################################################################################## + ((TH2F*)flistMCproperties->FindObject("hMCD0VsBhadrPt"))->Fill(mcD0Parent->Pt(),mcPart->Pt()); + ((TH2F*)flistMCproperties->FindObject("hMCD0VsBhadrEnergy"))->Fill(mcD0Parent->E(),mcPart->E()); + ((TH1F*)flistMCproperties->FindObject("hMCD0deltaBhadrEnergy"))->Fill(mcPart->E()/mcD0Parent->E()); + ((TH1F*)flistMCproperties->FindObject("hMCD0EnergyVsAvBDaughtEn"))->Fill((mcPart->E()-(mcD0Parent->E()/nBdaught))/mcD0Parent->E()); + //calculate open angle + if((pxyzMum[0]!=0.||pxyzMum[1]!=0.||pxyzMum[2]!=0.)&&(pxyzDaught[0]!=0.||pxyzDaught[1]!=0.||pxyzDaught[2]!=0.))cosOpenAngle=(pxyzDaught[0]*pxyzMum[0]+pxyzDaught[1]*pxyzMum[1]+pxyzDaught[2]*pxyzMum[2])/(TMath::Sqrt(pxyzDaught[0]*pxyzDaught[0]+pxyzDaught[1]*pxyzDaught[1]+pxyzDaught[2]*pxyzDaught[2])*TMath::Sqrt(pxyzDaught[0]*pxyzDaught[0]+pxyzDaught[1]*pxyzDaught[1]+pxyzDaught[2]*pxyzDaught[2])); + ((TH1F*)flistMCproperties->FindObject("hMCD0BhadrAngle"))->Fill(cosOpenAngle); + ((TH2F*)flistMCproperties->FindObject("hMCD0BhadrAngleEnergy"))->Fill(mcPart->E(),cosOpenAngle); + } + } + ((TH1F*)flistMCproperties->FindObject("hMCPartFound"))->Fill(1,cquarksMC); + ((TH1F*)flistMCproperties->FindObject("hMCPartFound"))->Fill(2,nD0all); + ((TH1F*)flistMCproperties->FindObject("hMCPartFound"))->Fill(3,nD0FromB); + ((TH1F*)flistMCproperties->FindObject("hMCPartFound"))->Fill(4,nD0bMeson); + ((TH1F*)flistMCproperties->FindObject("hMCPartFound"))->Fill(5,nD0bBaryon); + + } + + +void AliAnalysisTaskSECharmFraction::SetPtBins(Int_t nbins,const Float_t *ptbins){ + if((fptbins)!=0x0)delete fptbins; + fnbins=nbins;fptbins=new Float_t[fnbins]; + memcpy(fptbins,ptbins,fnbins*sizeof(Float_t)); return; } void AliAnalysisTaskSECharmFraction::SetStandardMassSelection(){ //SET THE DEFAULT VALUES FOR INVARIANT MASS SELECTION + + /*HERE DEFAULT + SetSignalInvMassCut(); + SetLargeInvMassCut(); + SetSideBandInvMassCut(); + SetSideBandInvMassWindow(); + */ + + // HERE FOR SEARCH FOR SIGNAL SetSignalInvMassCut(); SetLargeInvMassCut(); SetSideBandInvMassCut(); SetSideBandInvMassWindow(); return; +} + +Bool_t AliAnalysisTaskSECharmFraction::SpecialSelD0(AliAODRecoDecayHF2Prong *d,Int_t &nusedforVtx){ + + AliAODTrack *trk0 = (AliAODTrack*)d->GetDaughter(0); + AliAODTrack *trk1 = (AliAODTrack*)d->GetDaughter(1); + nusedforVtx=0; + if(trk0->GetUsedForPrimVtxFit())nusedforVtx++; + if(trk1->GetUsedForPrimVtxFit())nusedforVtx++; + if(nusedforVtx>fNtrMaxforVtx)return kFALSE; + + if(TMath::Abs(d->Getd0Prong(1)) < -99999. || + TMath::Abs(d->Getd0Prong(0)) < -99999.) return kFALSE; + + return kTRUE; +} + + + +AliAODVertex* AliAnalysisTaskSECharmFraction::GetPrimaryVtxSkipped(AliAODEvent *aodev,AliAODRecoDecayHF2Prong *d){ + //Calculate the primary vertex w/o the daughter tracks of the candidate + + AliESDVertex *vertexESD=0x0; + AliAODVertex *vertexAOD=0x0; + AliVertexerTracks *vertexer = new AliVertexerTracks(aodev->GetMagneticField()); + + Int_t skipped[2]; + Int_t nTrksToSkip=2; + AliAODTrack *dgTrack = (AliAODTrack*)d->GetDaughter(0); + skipped[0]=dgTrack->GetID(); + dgTrack = (AliAODTrack*)d->GetDaughter(1); + skipped[1]=dgTrack->GetID(); + + + // + vertexer->SetSkipTracks(nTrksToSkip,skipped); + vertexESD = (AliESDVertex*)vertexer->FindPrimaryVertex(aodev); + vertexer->SetMinClusters(4); + if(!vertexESD) return vertexAOD; + if(vertexESD->GetNContributors()<=0) { + AliDebug(2,"vertexing failed"); + delete vertexESD; vertexESD=NULL; + return vertexAOD; } + + delete vertexer; vertexer=NULL; + + + // convert to AliAODVertex + Double_t pos[3],cov[6],chi2perNDF; + vertexESD->GetXYZ(pos); // position + vertexESD->GetCovMatrix(cov); //covariance matrix + chi2perNDF = vertexESD->GetChi2toNDF(); + delete vertexESD; vertexESD=NULL; + + vertexAOD = new AliAODVertex(pos,cov,chi2perNDF); + return vertexAOD; + +} void AliAnalysisTaskSECharmFraction::Terminate(const Option_t*){ diff --git a/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.h b/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.h index 2a4fb757930..4f7ade69f45 100644 --- a/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.h +++ b/PWG3/vertexingHF/AliAnalysisTaskSECharmFraction.h @@ -21,15 +21,17 @@ class AliAODRecoDecayHF2Prong; class AliAODRecoDecayHF; class AliAODMCParticle; class AliAnalysisVertexingHF; +class AliRDHFCutsD0toKpi; #include "AliAnalysisTaskSE.h" class AliAnalysisTaskSECharmFraction : public AliAnalysisTaskSE { public: AliAnalysisTaskSECharmFraction(); AliAnalysisTaskSECharmFraction(const char *name); - AliAnalysisTaskSECharmFraction(const char *name,Int_t nptbins,Double_t *ptbins); - + AliAnalysisTaskSECharmFraction(const char *name,AliRDHFCutsD0toKpi *cutsA,AliRDHFCutsD0toKpi *cutsB); + virtual ~AliAnalysisTaskSECharmFraction(); + // Implementation of interface methods virtual void UserCreateOutputObjects(); virtual void Init(); @@ -37,7 +39,11 @@ class AliAnalysisTaskSECharmFraction : public AliAnalysisTaskSE { virtual void UserExec(Option_t *option); virtual void Terminate(Option_t *option); void SetReadMC(Bool_t readMC=kTRUE){fReadMC=readMC;} - void SetNPtBins(Int_t nbins,const Double_t *ptbins); + void SetUsePID(Bool_t pid){fusePID=pid;} + void SetAnalyzeLikeSign(Bool_t likesign=kFALSE){fLikeSign=likesign;} + void SetNMaxTrForVtx(const Int_t ntrMaxforVtx){fNtrMaxforVtx=ntrMaxforVtx;} + Int_t GetNMaxTrForVtx(){return fNtrMaxforVtx;} + void SetPtBins(Int_t nbins,const Float_t *ptbins); void SetSignalInvMassCut(const Double_t signalInvMassCut=0.027){fsignalInvMassCut=signalInvMassCut;} void SetLargeInvMassCut(const Double_t largeInvMassCut=2.){flargeInvMassCut=largeInvMassCut;} void SetSideBandInvMassCut(const Double_t sidebandInvMassCut=0.054){// default value ~ 2x3 times inv mass resol.: a factor 2 is applied w.r.t. 3sigma, should be safe enough to exclude most of the reflections @@ -46,40 +52,62 @@ class AliAnalysisTaskSECharmFraction : public AliAnalysisTaskSE { void SetSideBandInvMassWindow(const Double_t sidebandInvMassWindow=0.108){//~ 6 times inv. mass resol. fsidebandInvMassWindow=sidebandInvMassWindow; } - void SetAcceptanceCut(const Double_t eta=0.9,const Double_t nITSpoints=5.,const Double_t nSPDpoints=2.){fAcceptanceCuts[0]=eta;fAcceptanceCuts[1]=nITSpoints;fAcceptanceCuts[2]=nSPDpoints;} + void SetAcceptanceCut(const Double_t eta=0.8,const Double_t nITSpoints=5.,const Double_t nSPDpoints=2.){fAcceptanceCuts[0]=eta;fAcceptanceCuts[1]=nITSpoints;fAcceptanceCuts[2]=nSPDpoints;} void SetStandardMassSelection(); Int_t SetStandardCuts(Double_t pt,Double_t invMassCut); + Int_t SetStandardCuts(Float_t *&ptbinlimits); void CheckInvMassD0(AliAODRecoDecayHF2Prong *d,Double_t &invMassD0,Double_t &invMassD0bar,Bool_t &isPeakD0,Bool_t &isPeakD0bar,Bool_t &isSideBandD0,Bool_t &isSideBandD0bar); AliAODRecoDecayHF *GetD0toKPiSignalType(const AliAODRecoDecayHF2Prong *d,TClonesArray *arrayMC,Int_t &signaltype,Double_t &massMumTrue,Double_t *primaryVtx); AliAODRecoDecayHF* ConstructFakeTrueSecVtx(const AliAODMCParticle *b1,const AliAODMCParticle *b2,const AliAODMCParticle *mum,Double_t *primaryVtxTrue); void SetUseMC(Bool_t useMC){fUseMC=useMC;} - //################# - /* ######### THE FOLLOWING IS FOR FURTHER IMPLEMENATION ############ - Int_t GetPtBin(Double_t pt)const; - void SetD0Cuts(Int_t ptbin,Double_t &*d0cutsLoose,Double_t &*d0cutsTight); - - // void InvMassSelection(); - - void SetCheckMC(Bool_t checkMC){fcheckMC=checkMC;} - void SetCheckMC_D0(Bool_t check_D0){fcheckMCD0=check_D0;} - void SetCheckMC_2prongs(Bool_t check2prongs){fcheckMC2prongs=check2prongs;} - void SetCheckMC_prompt(Bool_t checkprompt){fcheckMCprompt=checkprompt;} - void SetCheckMC_fromB(Bool_t checkfromB){fcheckMCfromB=checkfromB;} - void SetCheckMC_fromDstar(Bool_t skipD0star){fSkipD0star=skipD0star;} - void SetUseCuts(Bool_t usecuts){fD0usecuts=usecuts;} - void SetSideBands(Double_t sideband){fSideBands=sideband;} - void SetStudyPureBackground(Bool_t back){fStudyPureBackground=back;} + Bool_t SpecialSelD0(AliAODRecoDecayHF2Prong *d,Int_t &nusedforVtx); + AliAODVertex* GetPrimaryVtxSkipped(AliAODEvent *aodev,AliAODRecoDecayHF2Prong *d); + + /* ######### THE FOLLOWING IS FOR FURTHER IMPLEMENATION ############ + Int_t GetPtBin(Double_t pt)const; + void SetD0Cuts(Int_t ptbin,Double_t &*d0cutsLoose,Double_t &*d0cutsTight); + + // void InvMassSelection(); + + void SetCheckMC(Bool_t checkMC){fcheckMC=checkMC;} + void SetCheckMC_D0(Bool_t check_D0){fcheckMCD0=check_D0;} + void SetCheckMC_2prongs(Bool_t check2prongs){fcheckMC2prongs=check2prongs;} + void SetCheckMC_prompt(Bool_t checkprompt){fcheckMCprompt=checkprompt;} + void SetCheckMC_fromB(Bool_t checkfromB){fcheckMCfromB=checkfromB;} + void SetCheckMC_fromDstar(Bool_t skipD0star){fSkipD0star=skipD0star;} + void SetUseCuts(Bool_t usecuts){fD0usecuts=usecuts;} + void SetSideBands(Double_t sideband){fSideBands=sideband;} + void SetStudyPureBackground(Bool_t back){fStudyPureBackground=back;} */ - + AliRDHFCutsD0toKpi* GetLooseCut(){ + return fCutsLoose; + } + AliRDHFCutsD0toKpi* GetTightCut(){ + return fCutsTight; + } + /* void SetCutFunction(Int_t (*setcuts)(AliAnalysisTaskSECharmFraction*,Double_t,Double_t)){ + fSetCuts=setcuts; + fStandCuts=kFALSE; + } + */ + // Int_t SetCuts(AliAnalysisTaskSECharmFraction *alchfr,Double_t pt,Double_t invMassCut); + private: Bool_t FillHistos(AliAODRecoDecayHF2Prong *d,TList *&list,Int_t ptbin,Int_t okD0,Int_t okD0bar,Double_t invMassD0,Double_t invMassD0bar,Bool_t isPeakD0,Bool_t isPeakD0bar,Bool_t isSideBand,Double_t massmumtrue,AliAODRecoDecayHF *aodDMC,Double_t *vtxTrue); - - AliAnalysisVertexingHF *fVHFloose; // Vertexer heavy flavour - AliAnalysisVertexingHF *fVHFtight; // Vertexer heavy flavour + void FillHistoMCproperties(TClonesArray *arrayMC); + + AliRDHFCutsD0toKpi *fCutsLoose; // Loose cuts object + AliRDHFCutsD0toKpi *fCutsTight; // Vertexer heavy flavour Bool_t fReadMC; // Flag To switch on/off access to MC + Bool_t fLikeSign; // Flag to analyse Like Sign array + Bool_t fusePID; // Flag to use PID Double_t fmD0PDG; // MC D0 mass Int_t fnbins; // Number of pt bins - Double_t *fptbins; //[fnbins] ptbins + Float_t *fptbins; //[fnbins] ptbins + Int_t fNtrMaxforVtx; // N Max acceptable tracks used for vertex (0,1,2) + Double_t fptAll; //!Sum of pt of the reco tracks + Double_t fptAllSq; //!Sum of the square of the pt of the reco tracks + Double_t fptMax[3]; //!Three largest track pt in the event Double_t fAcceptanceCuts[3]; // array with acceptance cuts Double_t fsignalInvMassCut; // invariant mass cut to define signal region Double_t flargeInvMassCut; // invariant mass cut to accept all inv mass window @@ -90,21 +118,22 @@ class AliAnalysisTaskSECharmFraction : public AliAnalysisTaskSE { TH1F *fSignalType; //!histo for the type of MC signal , container 2 TH1F *fSignalTypeLsCuts; //!histo for the type of MC signal with loose cuts , container 3 TH1F *fSignalTypeTghCuts; //!histo for the type of MC signal with tight cuts, container 4 - TList *flistNoCutsSignal; //!TList for signal (D prompt) with nocuts, container 5 - TList *flistNoCutsBack; //!TList for background with nocuts, container 6 - TList *flistNoCutsFromB; //!TList for D from B or D from Dstar from Bwith nocuts, container 7 - TList *flistNoCutsFromDstar; //!TList for D from Dstar with nocuts, container 8 - TList *flistNoCutsOther; //!TList for others with nocuts, container 9 - TList *flistLsCutsSignal; //!TList for signal (D prompt) with loose cuts, container 10 - TList *flistLsCutsBack; //!TList for background with loose cuts, container 11 - TList *flistLsCutsFromB; //!TList for D from B or D from Dstar from B with loose cuts, container 12 - TList *flistLsCutsFromDstar; //!TList for D from Dstar with loose cuts, container 13 - TList *flistLsCutsOther; //!TList for others with loose cuts, container 14 - TList *flistTghCutsSignal; //!TList for signal (D prompt) with tight cuts, container 15 - TList *flistTghCutsBack; //!TList for backgrnd with tight cuts, container 16 - TList *flistTghCutsFromB; //!TList for D from B or D from Dstar from Bwith tight cuts, container 17 - TList *flistTghCutsFromDstar; //!TList for D from Dstar Dstar with tight cuts, container 18 - TList *flistTghCutsOther; //!TList for others with tight cuts, container 19 + TList *flistMCproperties; //!TLists for MC properties of D0 w.r.t. B mesons and c quarks cntainer 5 + TList *flistNoCutsSignal; //!TList for signal (D prompt) with nocuts, container 6 + TList *flistNoCutsBack; //!TList for background with nocuts, container 7 + TList *flistNoCutsFromB; //!TList for D from B or D from Dstar from Bwith nocuts, container 8 + TList *flistNoCutsFromDstar; //!TList for D from Dstar with nocuts, container 9 + TList *flistNoCutsOther; //!TList for others with nocuts, container 10 + TList *flistLsCutsSignal; //!TList for signal (D prompt) with loose cuts, container 11 + TList *flistLsCutsBack; //!TList for background with loose cuts, container 12 + TList *flistLsCutsFromB; //!TList for D from B or D from Dstar from B with loose cuts, container 13 + TList *flistLsCutsFromDstar; //!TList for D from Dstar with loose cuts, container 14 + TList *flistLsCutsOther; //!TList for others with loose cuts, container 15 + TList *flistTghCutsSignal; //!TList for signal (D prompt) with tight cuts, container 16 + TList *flistTghCutsBack; //!TList for backgrnd with tight cuts, container 17 + TList *flistTghCutsFromB; //!TList for D from B or D from Dstar from Bwith tight cuts, container 18 + TList *flistTghCutsFromDstar; //!TList for D from Dstar Dstar with tight cuts, container 19 + TList *flistTghCutsOther; //!TList for others with tight cuts, container 20 /* Bool_t fD0usecuts; // Switch on the use of the cuts TO BE IMPLEMENTED Bool_t fcheckMC; // Switch on MC check: minimum check is same mother TO BE IMPLEMENTED Bool_t fcheckMCD0; // check the mother is a D0 TO BE IMPLEMENTED diff --git a/PWG3/vertexingHF/RunAnalysisAODVertexingHF.C b/PWG3/vertexingHF/RunAnalysisAODVertexingHF.C index 6f7501e9025..ea9f9843b65 100644 --- a/PWG3/vertexingHF/RunAnalysisAODVertexingHF.C +++ b/PWG3/vertexingHF/RunAnalysisAODVertexingHF.C @@ -223,10 +223,13 @@ void RunAnalysisAODVertexingHF() gROOT->LoadMacro(taskName.Data()); AliCFHeavyFlavourTaskMultiVarMultiStep *cfmvmsTask = AddTaskCFMultiVarMultiStep(); - taskName="AddTaskCharmFraction.C"; taskName.Prepend(loadMacroPath.Data()); + + taskName="AddTaskSECharmFraction.C"; + taskName.Prepend(loadMacroPath.Data()); gROOT->LoadMacro(taskName.Data()); - Int_t switchMC[5]={1,1,1,1,1}; - AliAnalysisTaskSECharmFraction *cFractTask = AddTaskCharmFraction("d0D0",switchMC); + Int_t switchMC[5]={0,0,0,0,0}; + // arguments: filename,switchMC,readmc,usepid,likesign,cutfilename,containerprefix + AliAnalysisTaskSECharmFraction *cFractTask = AddTaskSECharmFraction("standard",switchMC); // attach a private task (not committed) // (the files MyTask.h MyTask.cxx AddMyTask.C have to be declared in plugin -- 2.43.5