#pragma link C++ class AliSignificanceCalculator+;
#pragma link C++ class AliHFMassFitter+;
#pragma link C++ class AliHFPtSpectrum+;
+#pragma link C++ class AliNormalizationCounter+;
#pragma link C++ class AliAnalysisTaskSEBkgLikeSignJPSI+;
#pragma link C++ class AliAnalysisTaskSEBkgLikeSignD0+;
#pragma link C++ class AliAnalysisTaskSEJPSItoEle+;
vertexingHF/AliMultiDimVector.cxx vertexingHF/AliSignificanceCalculator.cxx \
vertexingHF/AliHFMassFitter.cxx \
vertexingHF/AliHFPtSpectrum.cxx \
+ vertexingHF/AliNormalizationCounter.cxx \
vertexingHF/AliAnalysisTaskSEBkgLikeSignJPSI.cxx \
vertexingHF/AliAnalysisTaskSEBkgLikeSignD0.cxx \
vertexingHF/AliAnalysisTaskSEJPSItoEle.cxx \
#include "AliAnalysisVertexingHF.h"
#include "AliAnalysisTaskSE.h"
#include "AliAnalysisTaskSED0Mass.h"
-
+#include "AliNormalizationCounter.h"
ClassImp(AliAnalysisTaskSED0Mass)
fReadMC(0),
fCutOnDistr(0),
fUsePid4Distr(0),
+fCounter(0),
fNPtBins(1),
fTotPosPairs(0),
fTotNegPairs(0),
fReadMC(0),
fCutOnDistr(0),
fUsePid4Distr(0),
+fCounter(0),
fNPtBins(1),
fTotPosPairs(0),
fTotNegPairs(0),
DefineOutput(4,TList::Class()); //My private output
// Output slot #5 writes into a TList container (cuts)
DefineOutput(5,AliRDHFCutsD0toKpi::Class()); //My private output
-
+ // Output slot #6 writes Normalization Counter
+ DefineOutput(6,AliNormalizationCounter::Class());
}
//________________________________________________________________________
delete fNentries;
fNentries = 0;
}
-
+ if(fCounter){
+ delete fCounter;
+ fCounter=0;
+ }
}
fNentries->GetXaxis()->SetBinLabel(14,"Lambda");
fNentries->GetXaxis()->SetNdivisions(1,kFALSE);
-
+ fCounter = new AliNormalizationCounter("NormalizationCounter");
+
// Post the data
PostData(1,fOutputMass);
PostData(2,fDistr);
PostData(3,fNentries);
PostData(4,fChecks);
-
+ PostData(6,fCounter);
return;
}
//histogram filled with 1 for every AOD
fNentries->Fill(0);
-
+ fCounter->StoreEvent(aod,fReadMC);
if(!fCuts->IsEventSelected(aod)) return;
// AOD primary vertex
}
//number of events with good vertex and at least 2 good tracks
if (isGoodTrack>=2 && isGoodVtx) fNentries->Fill(4);
-
+
// loop over candidates
Int_t nInD0toKpi = inputArray->GetEntriesFast();
if(fDebug>2) printf("Number of D0->Kpi: %d\n",nInD0toKpi);
// FILE *f=fopen("4display.txt","a");
// fprintf(f,"Number of D0->Kpi: %d\n",nInD0toKpi);
-
+ Int_t nSelectedloose=0,nSelectedtight=0;
for (Int_t iD0toKpi = 0; iD0toKpi < nInD0toKpi; iD0toKpi++) {
//Int_t nPosPairs=0, nNegPairs=0;
//cout<<"inside the loop"<<endl;
if(!(d->GetDaughter(0) || d->GetDaughter(1))) {
AliDebug(1,"at least one daughter not found!");
fNentries->Fill(6);
- return;
+ continue;
}
// Bool_t unsetvtx=kFALSE;
if ( fCuts->IsInFiducialAcceptance(d->Pt(),d->Y(421)) ) {
//if( TMath::Abs(eta0)<0.9 && TMath::Abs(eta1)<0.9 ){
//apply cuts on tracks
+ nSelectedloose++;
Int_t isSelected = fCuts->IsSelected(d,AliRDHFCuts::kTracks);
-
if(((AliAODTrack*)d->GetDaughter(0))->GetTPCNcls() < 70 || ((AliAODTrack*)d->GetDaughter(1))->GetTPCNcls() < 70) isSelected=kFALSE;
- if (!isSelected) return;
+ if (!isSelected) continue;
+ nSelectedtight++;
fNentries->Fill(7);
if(fDebug>2) cout<<"tracks selected"<<endl;
Int_t ptbin=fCuts->PtBin(d->Pt());
- if(ptbin==-1) {fNentries->Fill(5); return;} //out of bounds
+ if(ptbin==-1) {fNentries->Fill(5); continue;} //out of bounds
FillVarHists(aod,d,mcArray,fCuts,fDistr);
FillMassHists(aod,d,mcArray,fCuts,fOutputMass);
}
//if(unsetvtx) d->UnsetOwnPrimaryVtx();
} //end for prongs
-
-
+ fCounter->StoreCandidates(aod,nSelectedloose,kTRUE);
+ fCounter->StoreCandidates(aod,nSelectedtight,kFALSE);
// Post the data
PostData(1,fOutputMass);
PostData(2,fDistr);
PostData(3,fNentries);
PostData(4,fChecks);
-
+ PostData(6,fCounter);
return;
}
printf("ERROR: fChecks not available\n");
return;
}
-
-
+ fCounter = dynamic_cast<AliNormalizationCounter*>(GetOutputData(6));
+ if (!fCounter) {
+ printf("ERROR: fCounter not available\n");
+ return;
+ }
for(Int_t ipt=0;ipt<5;ipt++){ //change 5 in GetNPtBins when sure it is written and check
#include "AliAnalysisTaskSE.h"
#include "AliRDHFCutsD0toKpi.h"
+#include "AliNormalizationCounter.h"
class AliAODEvent;
Bool_t fReadMC; // flag for MC array: kTRUE = read it, kFALSE = do not read it
Bool_t fCutOnDistr; // flag to decide if apply cut also on distributions: 0 no cuts, 1 looser cuts, 2 tighter cuts
Bool_t fUsePid4Distr; // flag to use the particle identification to fill the signal histograms of distributions. It has effect only with fReadMC=kFALSE
+ AliNormalizationCounter *fCounter;//!AliNormalizationCounter on output slot 6
Int_t fNPtBins; // number of pt bins
Int_t* fTotPosPairs; //[fNPtBins]
Int_t* fTotNegPairs; //[fNPtBins]
Double_t fLsNormalization; // normalization
Int_t fFillOnlyD0D0bar; // flag to fill mass histogram with D0/D0bar only (0 = fill with both, 1 = fill with D0 only, 2 = fill with D0bar only)
- ClassDef(AliAnalysisTaskSED0Mass,9); // AliAnalysisTaskSE for the MC association of heavy-flavour decay candidates
+ ClassDef(AliAnalysisTaskSED0Mass,10); // AliAnalysisTaskSE for the MC association of heavy-flavour decay candidates
};
#endif
#include "AliAnalysisVertexingHF.h"
#include "AliAnalysisTaskSE.h"
#include "AliAnalysisTaskSEDplus.h"
+#include "AliNormalizationCounter.h"
ClassImp(AliAnalysisTaskSEDplus)
fListCuts(0),
fRDCutsProduction(0),
fRDCutsAnalysis(0),
+ fCounter(0),
fFillNtuple(kFALSE),
fReadMC(kFALSE),
+ fUseStrangeness(kFALSE),
fDoLS(kFALSE)
{
// Default constructor
fListCuts(0),
fRDCutsProduction(dpluscutsprod),
fRDCutsAnalysis(dpluscutsana),
+fCounter(0),
fFillNtuple(fillNtuple),
fReadMC(kFALSE),
+fUseStrangeness(kFALSE),
fDoLS(kFALSE)
{
//
// Output slot #2 writes cut to private output
// DefineOutput(2,AliRDHFCutsDplustoKpipi::Class());
DefineOutput(2,TList::Class());
+// Output slot #3 writes cut to private output
+ DefineOutput(3,AliNormalizationCounter::Class());
+
if(fFillNtuple){
- // Output slot #3 writes into a TNtuple container
- DefineOutput(3,TNtuple::Class()); //My private output
+ // Output slot #4 writes into a TNtuple container
+ DefineOutput(4,TNtuple::Class()); //My private output
}
}
fRDCutsAnalysis = 0;
}
+ if(fCounter){
+ delete fCounter;
+ fCounter = 0;
+ }
}
fOutput->Add(fYVsPtSig);
fOutput->Add(fYVsPtSigTC);
+
+ //Counter for Normalization
+ fCounter = new AliNormalizationCounter("NormalizationCounter");//new line
+
if(fFillNtuple){
OpenFile(2); // 2 is the slot number of the ntuple
AliAODEvent *aod = dynamic_cast<AliAODEvent*> (InputEvent());
+
+
TClonesArray *array3Prong = 0;
TClonesArray *arrayLikeSign =0;
if(!aod && AODEvent() && IsStandardAOD()) {
// fix for temporary bug in ESDfilter
// the AODs with null vertex pointer didn't pass the PhysSel
- if(!aod->GetPrimaryVertex() || TMath::Abs(aod->GetMagneticField())<0.001) return;
-
+ if(!aod->GetPrimaryVertex()||TMath::Abs(aod->GetMagneticField())<0.001) return;
+ fCounter->StoreEvent(aod,fReadMC);
fHistNEvents->Fill(0); // count event
// Post the data already here
PostData(1,fOutput);
Int_t pdgDgDplustoKpipi[3]={321,211,211};
// Double_t cutsDplus[12]={0.2,0.4,0.4,0.,0.,0.01,0.06,0.02,0.,0.85,0.,10000000000.};//TO REMOVE
//Double_t *cutsDplus = new (Double_t*)fRDCuts->GetCuts();
+ Int_t nSelectedloose=0,nSelectedtight=0;
for (Int_t i3Prong = 0; i3Prong < n3Prong; i3Prong++) {
AliAODRecoDecayHF3Prong *d = (AliAODRecoDecayHF3Prong*)array3Prong->UncheckedAt(i3Prong);
}
if(fRDCutsProduction->IsSelected(d,AliRDHFCuts::kCandidate)) {
+
+
+
Int_t iPtBin = -1;
Double_t ptCand = d->Pt();
}
Int_t passTightCuts=fRDCutsAnalysis->IsSelected(d,AliRDHFCuts::kCandidate);
+
Int_t labDp=-1;
Float_t deltaPx=0.;
index=GetHistoIndex(iPtBin);
if(isFidAcc){
+ nSelectedloose++;
fMassHist[index]->Fill(invMass);
fCosPHist[index]->Fill(cosp);
fDLenHist[index]->Fill(dlen);
fDCAHist[index]->Fill(dca);
if(passTightCuts){
+ nSelectedtight++;
fMassHistTC[index]->Fill(invMass);
if(d->GetCharge()>0) fMassHistTCPlus[index]->Fill(invMass);
else if(d->GetCharge()<0) fMassHistTCMinus[index]->Fill(invMass);
if(labDp>=0) {
index=GetSignalHistoIndex(iPtBin);
if(isFidAcc){
+ Float_t factor[3]={1.,1.,1.};
+ if(fUseStrangeness){
+ for(Int_t iprong=0;iprong<3;iprong++){
+ AliAODTrack *trad = (AliAODTrack*)d->GetDaughter(iprong);
+ Int_t labd= trad->GetLabel();
+ if(labd>=0){
+ AliAODMCParticle *dau = (AliAODMCParticle*)arrayMC->At(labd);
+ if(dau){
+ Int_t labm = dau->GetMother();
+ if(labm>=0){
+ AliAODMCParticle *mot = (AliAODMCParticle*)arrayMC->At(labm);
+ if(mot){
+ if(TMath::Abs(mot->GetPdgCode())==310 || TMath::Abs(mot->GetPdgCode())==130 || TMath::Abs(mot->GetPdgCode())==321){ //K0_S, K0_L, K^+-
+ if(d->PtProng(iprong)<=1)factor[iprong]=1./.7;
+ else factor[iprong]=1./.6;
+ // fNentries->Fill(12);
+ }
+ if(TMath::Abs(mot->GetPdgCode())==3122) { //Lambda
+ factor[iprong]=1./0.25;
+ // fNentries->Fill(13);
+ }//if 3122
+ }//if(mot)
+ }//if labm>0
+ }//if(dau)
+ }//if labd>=0
+ }//prong loop
+ }
+ Float_t fact=1.;for(Int_t k=0;k<3;k++)fact=fact*factor[k];
fMassHist[index]->Fill(invMass);
- fCosPHist[index]->Fill(cosp);
- fDLenHist[index]->Fill(dlen);
- fSumd02Hist[index]->Fill(sumD02);
- fSigVertHist[index]->Fill(sigvert);
- fPtMaxHist[index]->Fill(ptmax);
- fDCAHist[index]->Fill(dca);
+ fCosPHist[index]->Fill(cosp,fact);
+ fDLenHist[index]->Fill(dlen,fact);
+ Float_t sumd02s=d->Getd0Prong(0)*d->Getd0Prong(0)*factor[0]*factor[0]+d->Getd0Prong(1)*d->Getd0Prong(1)*factor[1]*factor[1]+d->Getd0Prong(2)*d->Getd0Prong(2)*factor[2]*factor[2];
+ fSumd02Hist[index]->Fill(sumd02s);
+ fSigVertHist[index]->Fill(sigvert,fact);
+ fPtMaxHist[index]->Fill(ptmax,fact);
+ fDCAHist[index]->Fill(dca,fact);
if(passTightCuts){
fMassHistTC[index]->Fill(invMass);
if(d->GetCharge()>0) fMassHistTCPlus[index]->Fill(invMass);
}else{
index=GetBackgroundHistoIndex(iPtBin);
if(isFidAcc){
+ Float_t factor[3]={1.,1.,1.};
+ if(fUseStrangeness){
+ for(Int_t iprong=0;iprong<3;iprong++){
+ AliAODTrack *trad = (AliAODTrack*)d->GetDaughter(iprong);
+ Int_t labd= trad->GetLabel();
+ if(labd>=0){
+ AliAODMCParticle *dau = (AliAODMCParticle*)arrayMC->At(labd);
+ if(dau){
+ Int_t labm = dau->GetMother();
+ if(labm>=0){
+ AliAODMCParticle *mot = (AliAODMCParticle*)arrayMC->At(labm);
+ if(mot){
+ if(TMath::Abs(mot->GetPdgCode())==310 || TMath::Abs(mot->GetPdgCode())==130 || TMath::Abs(mot->GetPdgCode())==321){ //K0_S, K0_L, K^+-
+ if(d->PtProng(iprong)<=1)factor[iprong]=1./.7;
+ else factor[iprong]=1./.6;
+ // fNentries->Fill(12);
+ }
+ if(TMath::Abs(mot->GetPdgCode())==3122) { //Lambda
+ factor[iprong]=1./0.25;
+ // fNentries->Fill(13);
+ }//if 3122
+ }//if(mot)
+ }//if labm>0
+ }//if(dau)
+ }//if labd>=0
+ }//prong loop
+ }
+ Float_t fact=1.;for(Int_t k=0;k<3;k++)fact=fact*factor[k];
fMassHist[index]->Fill(invMass);
- fCosPHist[index]->Fill(cosp);
- fDLenHist[index]->Fill(dlen);
- fSumd02Hist[index]->Fill(sumD02);
- fSigVertHist[index]->Fill(sigvert);
- fPtMaxHist[index]->Fill(ptmax);
- fDCAHist[index]->Fill(dca);
+ fCosPHist[index]->Fill(cosp,fact);
+ fDLenHist[index]->Fill(dlen,fact);
+ Float_t sumd02s=d->Getd0Prong(0)*d->Getd0Prong(0)*factor[0]*factor[0]+d->Getd0Prong(1)*d->Getd0Prong(1)*factor[1]*factor[1]+d->Getd0Prong(2)*d->Getd0Prong(2)*factor[2]*factor[2];
+ fSumd02Hist[index]->Fill(sumd02s);
+ fSigVertHist[index]->Fill(sigvert,fact);
+ fPtMaxHist[index]->Fill(ptmax,fact);
+ fDCAHist[index]->Fill(dca,fact);
if(passTightCuts){
fMassHistTC[index]->Fill(invMass);
if(d->GetCharge()>0) fMassHistTCPlus[index]->Fill(invMass);
}
}
}
- }
+ }
}
if(unsetvtx) d->UnsetOwnPrimaryVtx();
}
+ fCounter->StoreCandidates(aod,nSelectedloose,kTRUE);
+ fCounter->StoreCandidates(aod,nSelectedtight,kFALSE);
//start LS analysis
if(fDoLS && arrayLikeSign) LSAnalysis(array3Prong,arrayLikeSign,aod,vtx1,nOS);
PostData(1,fOutput);
+ PostData(3,fCounter);
return;
}
}
}
+ fCounter = dynamic_cast<AliNormalizationCounter*>(GetOutputData(3));
if(fFillNtuple){
- fNtupleDplus = dynamic_cast<TNtuple*>(GetOutputData(3));
+ fNtupleDplus = dynamic_cast<TNtuple*>(GetOutputData(4));
}
TCanvas *c1=new TCanvas("c1","D+ invariant mass distribution",500,500);
#include "AliRDHFCutsDplustoKpipi.h"
#include "AliAnalysisTaskSE.h"
#include "AliAnalysisVertexingHF.h"
+#include "AliNormalizationCounter.h"
class AliAnalysisTaskSEDplus : public AliAnalysisTaskSE
{
void SetReadMC(Bool_t readMC=kTRUE){fReadMC=readMC;}
void SetDoLikeSign(Bool_t dols=kTRUE){fDoLS=dols;}
+ void SetUseStrangeness(Bool_t uses=kTRUE){fUseStrangeness=uses;}
void SetMassLimits(Float_t range);
void SetMassLimits(Float_t lowlimit, Float_t uplimit);
void SetPtBinLimit(Int_t n, Float_t *limitarray);
TList *fListCuts; //list of cuts
AliRDHFCutsDplustoKpipi *fRDCutsProduction; //Production D+ Cuts
AliRDHFCutsDplustoKpipi *fRDCutsAnalysis; //Cuts for Analysis
+ AliNormalizationCounter *fCounter;//!Counter for normalization
Double_t fArrayBinLimits[kMaxPtBins+1]; //limits for the Pt bins
Bool_t fFillNtuple; // flag for filling ntuple
Bool_t fReadMC; //flag for access to MC
+ Bool_t fUseStrangeness;//flag to enhance strangeness in MC to fit to data
Bool_t fDoLS; //flag to do LS analysis
- ClassDef(AliAnalysisTaskSEDplus,8); // AliAnalysisTaskSE for the MC association of heavy-flavour decay candidates
+ ClassDef(AliAnalysisTaskSEDplus,9); // AliAnalysisTaskSE for the MC association of heavy-flavour decay candidates
};
#endif
--- /dev/null
+#include "AliNormalizationCounter.h"
+#include <AliESDEvent.h>
+#include <AliESDtrack.h>
+#include <AliAODEvent.h>
+#include <AliVParticle.h>
+#include <AliTriggerAnalysis.h>
+#include <TH1F.h>
+#include <TH2D.h>
+#include <TList.h>
+#include <TString.h>
+#include <TCanvas.h>
+#include <AliPhysicsSelection.h>
+
+ClassImp(AliNormalizationCounter)
+
+//____________________________________________
+AliNormalizationCounter::AliNormalizationCounter():
+AliCounterCollection(),
+fESD(kFALSE)
+{
+ // empty constructor
+}
+
+//__________________________________________________
+AliNormalizationCounter::AliNormalizationCounter(const char *name):
+AliCounterCollection(name),
+fESD(kFALSE)
+{
+ //default constructor
+ AddRubric("Event","triggered/V0AND/Candles0.2/Candles0.25/Candles0.3/2xCandles0.2/PrimaryVTracks/PrimaryV/!V0A&Candle02/!V0A&Candle025/!V0A&Candle03/!V0A&PrimaryVTracks/!V0A&PrimaryV/!V0A&2xCandles02/Candid(Filter)/Candid(Analysis)/NCandid(Filter)/NCandid(Analysis)");//new line
+ AddRubric("Run", 10000000);//new line
+ Init();//new line
+}
+//______________________________________________
+AliNormalizationCounter::~AliNormalizationCounter()
+{
+ //destructor
+}
+
+
+//_______________________________________
+void AliNormalizationCounter::StoreEvent(AliVEvent *event,Bool_t mc){
+ //
+
+ Bool_t v0A=kFALSE;
+ Bool_t v0B=kFALSE;
+ Bool_t flag02=kFALSE;
+ Bool_t flag025=kFALSE;
+ Bool_t flag03=kFALSE;
+ Int_t flag0202=0;
+ Bool_t flagPV=kFALSE;
+ Bool_t flagPVT=kFALSE;
+
+ //Run Number
+ Int_t runNumber = event->GetRunNumber();
+
+ //Find CINT1B
+
+ AliESDEvent *eventESD = (AliESDEvent*)event;
+ if(!eventESD){AliError("ESD event not available");return;}
+ if(mc&&event->GetEventType() != 0)return;
+ //event must be either physics or MC
+ if(!(event->GetEventType() == 7||event->GetEventType() == 0))return;
+
+ Count(Form("Event:triggered/Run:%d",runNumber));
+
+ //Find V0AND
+ AliTriggerAnalysis trAn; /// Trigger Analysis
+ v0B = trAn.IsOfflineTriggerFired(eventESD , AliTriggerAnalysis::kV0C);
+ v0A = trAn.IsOfflineTriggerFired(eventESD , AliTriggerAnalysis::kV0A);
+ if(v0A&&v0B){Count(Form("Event:V0AND/Run:%d",runNumber));}
+
+ //Find Candle
+ Int_t trkEntries = (Int_t)event->GetNumberOfTracks();
+
+ for(Int_t i=0;i<trkEntries;i++){
+ AliAODTrack *track=(AliAODTrack*)event->GetTrack(i);
+ UShort_t nClusTPC=track->GetTPCNcls();
+ if((nClusTPC>=70)&&(track->GetStatus()&AliESDtrack::kITSrefit)&&(track->GetStatus()&AliESDtrack::kTPCrefit)){
+
+ if((track->Pt()>0.2)&&flag0202<2){
+ if(!flag02)Count(Form("Event:Candles0.2/Run:%d",runNumber));
+ flag02=kTRUE;
+ flag0202++;
+ }
+ if((track->Pt()>0.25)&&(!flag025)){
+ Count(Form("Event:Candles0.25/Run:%d",runNumber));
+ flag025=kTRUE;
+ }
+ if((track->Pt()>0.3)&&(!flag03)){
+ Count(Form("Event:Candles0.3/Run:%d",runNumber));
+ flag03=kTRUE;
+ }
+ }
+ if((flag02)&&(flag025)&&(flag03)&&flag0202>=2) break; //i=trkEntries+1;
+ }
+
+ //FindPrimary vertex
+ AliVVertex *vtrc = (AliVVertex*)event->GetPrimaryVertex();
+ if(vtrc && vtrc->GetNContributors()>0){
+ Count(Form("Event:PrimaryV/Run:%d",runNumber));
+ flagPV=kTRUE;
+ }
+
+ if(fESD){
+ const AliESDVertex *vtrc1 = eventESD->GetPrimaryVertexTracks();
+ if(vtrc1 && vtrc1->GetNContributors()>0){
+ Count(Form("Event:PrimaryVTracks/Run:%d",runNumber));
+ flagPVT=kTRUE;
+ }
+ }
+
+ if(!(v0A&&v0B)&&(flag02))Count(Form("Event:!V0A&Candle02/Run:%d",runNumber));
+ if(!(v0A&&v0B)&&(flag025))Count(Form("Event:!V0A&Candle025/Run:%d",runNumber));
+ if(!(v0A&&v0B)&&(flag03))Count(Form("Event:!V0A&Candle03/Run:%d",runNumber));
+ if(!(v0A&&v0B)&&flagPVT)Count(Form("Event:!V0A&PrimaryVTracks/Run:%d",runNumber));
+ if(!(v0A&&v0B)&&flagPV)Count(Form("Event:!V0A&PrimaryV/Run:%d",runNumber));
+ if(flag0202>1)Count(Form("Event:2xCandles0.2/Run:%d",runNumber));
+ if(!(v0A&&v0B)&&flag0202>1)Count(Form("Event:!V0A&2xCandles02/Run:%d",runNumber));
+
+ //delete eventESD;
+
+ return;
+}
+//_____________________________________________________________________
+void AliNormalizationCounter::StoreCandidates(AliVEvent *event,Int_t nCand,Bool_t flagFilter){
+ //
+
+ Int_t runNumber = event->GetRunNumber();
+ if(nCand==0)return;
+ if(flagFilter){
+ Count(Form("Event:Candid(Filter)/Run:%d",runNumber));
+ for(Int_t i=0;i<nCand;i++)Count(Form("Event:NCandid(Filter)/Run:%d",runNumber));
+ }else{
+ Count(Form("Event:Candid(Analysis)/Run:%d",runNumber));
+ for(Int_t i=0;i<nCand;i++)Count(Form("Event:NCandid(Analysis)/Run:%d",runNumber));
+ }
+ return;
+}
+//_______________________________________________________________________
+TH1D* AliNormalizationCounter::DrawAgainstRuns(TString candle="candid(filter)"){
+ //
+ TString selection;
+ selection.Form("event:%s",candle.Data());
+ TH2D* hist = Draw("event","run",selection.Data());
+ TH1D* histoneD =(TH1D*)(hist->ProjectionX()->Clone());
+ histoneD->DrawClone();
+ return histoneD;
+}
+//___________________________________________________________________________
+TH1D* AliNormalizationCounter::DrawRatio(TString candle1="candid(filter)",TString candle2="triggered"){
+ //
+ TString name;
+ name.Form("%s/%s",candle1.Data(),candle2.Data());
+ TH1D* num=(TH1D*)(DrawAgainstRuns(candle1.Data())->Clone(name.Data()));
+ TH1D* den=DrawAgainstRuns(candle2.Data());
+ den->SetTitle(candle2.Data());
+ den->SetName(candle2.Data());
+ printf("%f %f",num->GetEntries(),den->GetEntries());
+ num->Divide(num,den,1,1,"B");
+ num->DrawClone();
+ return num;
+}
+
--- /dev/null
+#ifndef ALINORMALIZATIONCOUNTER_H
+#define ALINORMALIZATIONCOUNTER_H
+
+#include <TROOT.h>
+#include <TSystem.h>
+#include <TNtuple.h>
+#include <TH1F.h>
+#include <TH1D.h>
+#include <AliESDEvent.h>
+#include <AliESDtrack.h>
+#include <AliAODTrack.h>
+#include <AliAODEvent.h>
+#include <AliVParticle.h>
+#include "AliAnalysisTaskSE.h"
+#include "AliCounterCollection.h"
+//#include "AliAnalysisVertexingHF.h"
+
+class AliNormalizationCounter : public AliCounterCollection
+{
+ public:
+
+ AliNormalizationCounter();
+ AliNormalizationCounter(const char *name);
+ virtual ~AliNormalizationCounter();
+
+ void SetESD(Bool_t flag){fESD=flag;}
+ void StoreEvent(AliVEvent*,Bool_t mc=kFALSE);
+ void StoreCandidates(AliVEvent*, Int_t nCand=0,Bool_t flagFilter=kTRUE);
+ TH1D* DrawAgainstRuns(TString candle);
+ TH1D* DrawRatio(TString candle1,TString candle2);
+ private:
+ AliNormalizationCounter(const AliNormalizationCounter &source);
+ AliNormalizationCounter& operator=(const AliNormalizationCounter& source);
+ Bool_t fESD; //flag for ESD vs AOD
+
+ ClassDef(AliNormalizationCounter,1);
+
+};
+#endif
-AliAnalysisTaskSED0Mass *AddTaskD0Mass(TString finname="D0toKpiCutsNew.root",Int_t flag=0/*0 = D0,1 = LS*/,Bool_t readMC=kFALSE,Bool_t cutOnDistr=kFALSE,Int_t flagD0D0bar=0)
+AliAnalysisTaskSED0Mass *AddTaskD0Mass(TString finname="D0toKpiCuts.root",Int_t flag=0/*0 = D0,1 = LS*/,Bool_t readMC=kFALSE,Bool_t cutOnDistr=kFALSE,Int_t flagD0D0bar=0)
{
//
// AddTask for the AliAnalysisTaskSE for D0 candidates
return NULL;
}
- TString filename="",out1name="",out2name="",out3name="",out4name="",out5name="",inname="";
+ TString filename="",out1name="",out2name="",out3name="",out4name="",out5name="",out6name="",inname="";
filename = AliAnalysisManager::GetCommonFileName();
filename += ":PWG3_D2H_";
if(flag==0){
if(flagD0D0bar==1)out5name+="D0";
if(flagD0D0bar==2)out5name+="D0bar";
+ //AliNormalizationCounter
+ out6name="normalizationCounter";
+ if(cutOnDistr) out6name+="C";
+ if(flagD0D0bar==1)out6name+="D0";
+ if(flagD0D0bar==2)out6name+="D0bar";
+
inname="cinputmassD0_0";
if(cutOnDistr) inname+="C";
if(flagD0D0bar==1)inname+="D0";
AliAnalysisDataContainer *coutputmassD03 = mgr->CreateContainer(out3name,TH1F::Class(),AliAnalysisManager::kOutputContainer, filename.Data()); //nev
AliAnalysisDataContainer *coutputmassD04 = mgr->CreateContainer(out4name,TList::Class(),AliAnalysisManager::kOutputContainer, filename.Data()); //check
AliAnalysisDataContainer *coutputmassD05 = mgr->CreateContainer(out5name,AliRDHFCutsD0toKpi::Class(),AliAnalysisManager::kOutputContainer, filename.Data()); //cuts
+ AliAnalysisDataContainer *coutputmassD06 = mgr->CreateContainer(out6name,AliNormalizationCounter::Class(),AliAnalysisManager::kOutputContainer, filename.Data()); //cuts
mgr->ConnectInput(massD0Task,0,mgr->GetCommonInputContainer());
mgr->ConnectOutput(massD0Task,3,coutputmassD03);
mgr->ConnectOutput(massD0Task,4,coutputmassD04);
mgr->ConnectOutput(massD0Task,5,coutputmassD05);
+ mgr->ConnectOutput(massD0Task,6,coutputmassD06);
return massD0Task;
AliAnalysisDataContainer *coutputDplus = mgr->CreateContainer("coutputDplus",TList::Class(),
AliAnalysisManager::kOutputContainer,
outputfile.Data());
+ AliAnalysisDataContainer *coutputDplusNorm = mgr->CreateContainer("coutputDplusNorm",AliNormalizationCounter::Class(),
+ AliAnalysisManager::kOutputContainer,
+ outputfile.Data());
if(storeNtuple){
AliAnalysisDataContainer *coutputDplus2 = mgr->CreateContainer("coutputDplus2",TNtuple::Class(),
mgr->ConnectOutput(dplusTask,1,coutputDplus);
mgr->ConnectOutput(dplusTask,2,coutputDplusCuts);
-
+
+ mgr->ConnectOutput(dplusTask,3,coutputDplusNorm);
if(storeNtuple){
- mgr->ConnectOutput(dplusTask,3,coutputDplus2);
+ mgr->ConnectOutput(dplusTask,4,coutputDplus2);
}
return dplusTask;
}
git://git.uio.no / u / mrichter / AliRoot.git / commitdiff