/************************************************************************** * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. * * * * Author: The ALICE Off-line Project. * * Contributors are mentioned in the code where appropriate. * * * * Permission to use, copy, modify and distribute this software and its * * documentation strictly for non-commercial purposes is hereby granted * * without fee, provided that the above copyright notice appears in all * * copies and that both the copyright notice and this permission notice * * appear in the supporting documentation. The authors make no claims * * about the suitability of this software for any purpose. It is * * provided "as is" without express or implied warranty. * **************************************************************************/ #include #include #include #include #include #include #include #include #include #include #include "AliAnalysisTaskFragmentationFunction.h" #include "AliAnalysisManager.h" #include "AliInputEventHandler.h" #include "AliAODHandler.h" #include "AliAODTrack.h" #include "AliJetHeader.h" #include "AliAODEvent.h" #include "AliAODJet.h" #include "AliAODDiJet.h" #include "AliGenPythiaEventHeader.h" #include "AliAnalysisHelperJetTasks.h" #include "AliMCEvent.h" #include "AliMCParticle.h" #include "AliAODMCParticle.h" ClassImp(AliAnalysisTaskFragmentationFunction) //####################################################################### AliAnalysisTaskFragmentationFunction::AliAnalysisTaskFragmentationFunction(): AliAnalysisTaskSE(), fJetHeaderRec(0x0), fJetHeaderGen(0x0), fAOD(0x0), fBranchRec(""), fBranchGen(""), fUseAODInput(kFALSE), fUseAODJetInput(kFALSE), fUseAODTrackInput(kFALSE), fUseAODMCInput(kFALSE), fUseGlobalSelection(kFALSE), fUseExternalWeightOnly(kFALSE), fLimitGenJetEta(kFALSE), fFilterMask(0), fAnalysisType(0), fTrackTypeRec(kTrackUndef), fTrackTypeGen(kTrackUndef), fAvgTrials(1.), fExternalWeight(1.), fRecEtaWindow(0.5), fR(0.), fdRdNdxi(0.7), fPartPtCut(0.), fEfactor(1.), fNff(5), fNim(5), fList(0x0), fGlobVar(1), // Number of energy bins fnEBin(6), fEmin(10.), fEmax(70.), fnEInterval(6), // Number of radius bins fnRBin(10), fRmin(0.1), fRmax(1.), fnRInterval(9), // eta histograms fnEtaHBin(50), fEtaHBinMin(-0.9), fEtaHBinMax(0.9), // phi histograms fnPhiHBin(60), fPhiHBinMin(0.), fPhiHBinMax(2*TMath::Pi()), // pt histograms fnPtHBin(300), fPtHBinMin(0.), fPtHBinMax(300.), // E histograms fnEHBin(300), fEHBinMin(0.), fEHBinMax(300.), // Xi histograms fnXiHBin(27), fXiHBinMin(0.), fXiHBinMax(9.), // Pthad histograms fnPthadHBin(60), fPthadHBinMin(0.), fPthadHBinMax(30.), // z histograms fnZHBin(30), fZHBinMin(0.), fZHBinMax(1.), // theta histograms fnThetaHBin(200), fThetaHBinMin(-0.5), fThetaHBinMax(1.5), fnCosThetaHBin(100), fcosThetaHBinMin(0.), fcosThetaHBinMax(1.), // kT histograms fnkTHBin(25), fkTHBinMin(0.), fkTHBinMax(5.), // kT histograms fnRHBin(10), fRHBinMin(0), fRHBinMax(1), // pt trig fnPtTrigBin(10), //Histograms fEtaMonoJet1H(0x0), fPhiMonoJet1H(0x0), fPtMonoJet1H(0x0), fEMonoJet1H(0x0), fdNdXiMonoJet1H(0x0), fdNdPtMonoJet1H(0x0), fdNdZMonoJet1H(0x0), fdNdThetaMonoJet1H(0x0), fdNdcosThetaMonoJet1H(0x0), fdNdkTMonoJet1H(0x0), fdNdpTvsZMonoJet1H(0x0), fShapeMonoJet1H(0x0), fNMonoJet1sH(0x0), fThetaPtPartMonoJet1H(0x0), fcosThetaPtPartMonoJet1H(0x0), fkTPtPartMonoJet1H(0x0), fThetaPtJetMonoJet1H(0x0), fcosThetaPtJetMonoJet1H(0x0), fkTPtJetMonoJet1H(0x0), fpTPtJetMonoJet1H(0x0), farrayEmin(0x0), farrayEmax(0x0), farrayRadii(0x0), farrayPtTrigmin(0x0), farrayPtTrigmax(0x0), // Track control plots fptAllTracks(0x0), fetaAllTracks(0x0), fphiAllTracks(0x0), fetaphiptAllTracks(0x0), fetaphiAllTracks(0x0), fptAllTracksCut(0x0), fetaAllTracksCut(0x0), fphiAllTracksCut(0x0), fetaphiptAllTracksCut(0x0), fetaphiAllTracksCut(0x0), fptTracks(0x0), fetaTracks(0x0), fphiTracks(0x0), fdetaTracks(0x0), fdphiTracks(0x0), fetaphiptTracks(0x0), fetaphiTracks(0x0), fdetadphiTracks(0x0), fptTracksCut(0x0), fetaTracksCut(0x0), fphiTracksCut(0x0), fdetaTracksCut(0x0), fdphiTracksCut(0x0), fetaphiptTracksCut(0x0), fetaphiTracksCut(0x0), fdetadphiTracksCut(0x0), fNPtTrig(0x0), fNPtTrigCut(0x0), fvertexXY(0x0), fvertexZ(0x0), fEvtMult(0x0), fEvtMultvsJetPt(0x0), fPtvsEtaJet(0x0), fNpvsEtaJet(0x0), fNpevtvsEtaJet(0x0), fPtvsPtJet(0x0), fNpvsPtJet(0x0), fNpevtvsPtJet(0x0), fPtvsPtJet1D(0x0), fNpvsPtJet1D(0x0), fNpevtvsPtJet1D(0x0), fptLeadingJet(0x0), fetaLeadingJet(0x0), fphiLeadingJet(0x0), fptJet(0x0), fetaJet(0x0), fphiJet(0x0), fHistList(0x0), fNBadRuns(0), fNBadRunsH(0x0) { // // Default constructor // /* for(int i = 0;i < kMaxStep*2;++i){ fhnJetContainer[i] = 0; } */ // for(int ij = 0;ijGetTree(); // UInt_t ntrials = 0; // Float_t ftrials = 0; // if(tree){ // TFile *curfile = tree->GetCurrentFile(); // if (!curfile) { // Error("Notify","No current file"); // return kFALSE; // } // if(!fh1Xsec||!fh1Trials){ // Printf("%s%d No Histogram fh1Xsec",(char*)__FILE__,__LINE__); // return kFALSE; // } // TString fileName(curfile->GetName()); // if(fileName.Contains("AliESDs.root")){ // fileName.ReplaceAll("AliESDs.root", "pyxsec.root"); // } // else if(fileName.Contains("AliAOD.root")){ // fileName.ReplaceAll("AliAOD.root", "pyxsec.root"); // } // else if(fileName.Contains("AliAODs.root")){ // fileName.ReplaceAll("AliAODs.root", ""); // } // else if(fileName.Contains("galice.root")){ // // for running with galice and kinematics alone... // fileName.ReplaceAll("galice.root", "pyxsec.root"); // } // TFile *fxsec = TFile::Open(fileName.Data()); // if(!fxsec){ // Printf("%s:%d %s not found in the Input",(char*)__FILE__,__LINE__,fileName.Data()); // // no a severe condition // return kTRUE; // } // TTree *xtree = (TTree*)fxsec->Get("Xsection"); // if(!xtree){ // Printf("%s:%d tree not found in the pyxsec.root",(char*)__FILE__,__LINE__); // } // xtree->SetBranchAddress("xsection",&fXsection); // xtree->SetBranchAddress("ntrials",&ntrials); // ftrials = ntrials; // xtree->GetEntry(0); // fh1Xsec->Fill("<#sigma>",fXsection); // fh1Trials->Fill("#sum{ntrials}",ftrials); // } return kTRUE; } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// void AliAnalysisTaskFragmentationFunction::UserCreateOutputObjects() { // // Create the output container // //**** Connect the AOD if(fUseAODInput) // Use AODs as input not ESDs { fAOD = dynamic_cast(InputEvent()); if(!fAOD) { Printf("%s:%d AODEvent not found in Input Manager %d",(char*)__FILE__,__LINE__,fUseAODInput); return; } // fetch the header fJetHeaderRec = dynamic_cast(fInputHandler->GetTree()->GetUserInfo()->FindObject(Form("AliJetHeader_%s",fBranchRec.Data()))); if(!fJetHeaderRec) { Printf("%s:%d Jet Header not found in the Input",(char*)__FILE__,__LINE__); } } else // Use the AOD on the flight { // assume that the AOD is in the general output... fAOD = AODEvent(); if(!fAOD) { Printf("%s:%d AODEvent not found in the Output",(char*)__FILE__,__LINE__); return; } // ((TList*)OutputTree()->GetUserInfo())->Dump(); fJetHeaderRec = dynamic_cast(OutputTree()->GetUserInfo()->FindObject(Form("AliJetHeader_%s",fBranchRec.Data()))); if(!fJetHeaderRec) { Printf("%s:%d Jet Header not found in the Output",(char*)__FILE__,__LINE__); } else { if(fDebug>10)fJetHeaderRec->Dump(); } } //////////////////////////// if (fDebug > 1) printf("AnalysisTaskJetSpectrum::UserCreateOutputObjects() \n"); OpenFile(1); if(!fHistList)fHistList = new TList(); fHistList->SetOwner(kTRUE); Bool_t oldStatus = TH1::AddDirectoryStatus(); TH1::AddDirectory(kFALSE); ////////////////////////////////////////////////// //////////// HISTOGRAM DECLARATION /////////////// ////////////////////////////////////////////////// DefineJetH(); ////////////////////////////////////////////////// ////////////// HISTOGRAM SAVING ////////////////// ////////////////////////////////////////////////// for (Int_t i3 = 0; i3 < fnEBin; i3++) { fHistList->Add(fEtaMonoJet1H[i3]); fHistList->Add(fPhiMonoJet1H[i3]); fHistList->Add(fPtMonoJet1H[i3]); fHistList->Add(fEMonoJet1H[i3]); for(Int_t i4 = 0; i4 < fnRBin; i4++) { fHistList->Add(fdNdXiMonoJet1H[i3][i4]); fHistList->Add(fdNdPtMonoJet1H[i3][i4]); fHistList->Add(fdNdZMonoJet1H[i3][i4]); fHistList->Add(fNMonoJet1sH[i3][i4]); } } // Theta, kT particles/jet for (Int_t i3 = 0; i3 < fnEBin; i3++) { for(Int_t i4 = 0; i4 < fnRBin; i4++) { fHistList->Add(fdNdThetaMonoJet1H[i3][i4]); fHistList->Add(fdNdcosThetaMonoJet1H[i3][i4]); fHistList->Add(fdNdkTMonoJet1H[i3][i4]); fHistList->Add(fdNdpTvsZMonoJet1H[i3][i4]); fHistList->Add(fShapeMonoJet1H[i3][i4]); fHistList->Add(fThetaPtPartMonoJet1H[i3][i4]); fHistList->Add(fcosThetaPtPartMonoJet1H[i3][i4]); fHistList->Add(fkTPtPartMonoJet1H[i3][i4]); fHistList->Add(fThetaPtJetMonoJet1H[i3][i4]); fHistList->Add(fcosThetaPtJetMonoJet1H[i3][i4]); fHistList->Add(fkTPtJetMonoJet1H[i3][i4]); fHistList->Add(fpTPtJetMonoJet1H[i3][i4]); } } // Track QA - Correlations for (Int_t iPtBin=0; iPtBinAdd(fptTracks[iPtBin]); fHistList->Add(fetaTracks[iPtBin]); fHistList->Add(fphiTracks[iPtBin]); fHistList->Add(fdetaTracks[iPtBin]); fHistList->Add(fdphiTracks[iPtBin]); fHistList->Add(fetaphiptTracks[iPtBin]); fHistList->Add(fetaphiTracks[iPtBin]); fHistList->Add(fdetadphiTracks[iPtBin]); fHistList->Add(fptTracksCut[iPtBin]); fHistList->Add(fetaTracksCut[iPtBin]); fHistList->Add(fphiTracksCut[iPtBin]); fHistList->Add(fdetaTracksCut[iPtBin]); fHistList->Add(fdphiTracksCut[iPtBin]); fHistList->Add(fetaphiptTracksCut[iPtBin]); fHistList->Add(fetaphiTracksCut[iPtBin]); fHistList->Add(fdetadphiTracksCut[iPtBin]); fHistList->Add(fNPtTrig[iPtBin]); fHistList->Add(fNPtTrigCut[iPtBin]); } // Track QA fHistList->Add(fptAllTracks); fHistList->Add(fetaAllTracks); fHistList->Add(fphiAllTracks); fHistList->Add(fetaphiptAllTracks); fHistList->Add(fetaphiAllTracks); fHistList->Add(fptAllTracksCut); fHistList->Add(fetaAllTracksCut); fHistList->Add(fphiAllTracksCut); fHistList->Add(fetaphiptAllTracksCut); fHistList->Add(fetaphiAllTracksCut); // Event caracterisation QA fHistList->Add(fvertexXY); fHistList->Add(fvertexZ); fHistList->Add(fEvtMult); fHistList->Add(fEvtMultvsJetPt); fHistList->Add(fPtvsEtaJet); fHistList->Add(fNpvsEtaJet); fHistList->Add(fNpevtvsEtaJet); fHistList->Add(fPtvsPtJet); fHistList->Add(fNpvsPtJet); fHistList->Add(fNpevtvsPtJet); fHistList->Add(fPtvsPtJet1D); fHistList->Add(fNpvsPtJet1D); fHistList->Add(fNpevtvsPtJet1D); fHistList->Add(fptLeadingJet); fHistList->Add(fetaLeadingJet); fHistList->Add(fphiLeadingJet); fHistList->Add(fptJet); fHistList->Add(fetaJet); fHistList->Add(fphiJet); fHistList->Add(fNBadRunsH); ////////////////////////////////////////////////// ///////// END OF HISTOGRAM DECLARATION /////////// ////////////////////////////////////////////////// // =========== Switch on Sumw2 for all histos =========== for (Int_t i=0; iGetEntries(); ++i) { TH1 *h1 = dynamic_cast(fHistList->At(i)); if (h1) { // Printf("%s ",h1->GetName()); h1->Sumw2(); continue; } } TH1::AddDirectory(oldStatus); /* if (fDebug > 1) printf("AnalysisTaskDiJets::CreateOutPutData() \n"); fDiJets = new TClonesArray("AliAODDiJet", 0); fDiJets->SetName("Dijets"); AddAODBranch("TClonesArray", &fDiJets); */ } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// void AliAnalysisTaskFragmentationFunction::Init() { // // Initialization // Printf(">>> AnalysisTaskFragmentationFunction::Init() debug level %d\n",fDebug); if (fDebug > 1) printf("AnalysisTaskDiJets::Init() \n"); } ///////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////// void AliAnalysisTaskFragmentationFunction::UserExec(Option_t */*option*/) { // // Execute analysis for current event // //**** //**** Check of input data //**** printf("Analysing event # %5d\n", (Int_t) fEntry); if (fDebug > 1)printf("Analysing event # %5d\n", (Int_t) fEntry); AliAODHandler *aodH = dynamic_cast(AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler()); if(!aodH) { Printf("%s:%d no output aodHandler found Jet",(char*)__FILE__,__LINE__); return; } TClonesArray *aodRecJets = dynamic_cast(fAOD->FindListObject(fBranchRec.Data())); if(!aodRecJets) { Printf("%s:%d no reconstructed Jet array with name %s in AOD",(char*)__FILE__,__LINE__,fBranchRec.Data()); return; } if (fDebug > 10) Printf("%s:%d",(char*)__FILE__,__LINE__); //**** //**** Check of primary vertex //**** AliAODVertex * pvtx = dynamic_cast(fAOD->GetPrimaryVertex()); if( (!pvtx) || (pvtx->GetZ()<-10. || pvtx->GetZ()>10.) || (pvtx->GetNContributors()<0) ) { fNBadRuns++; fNBadRunsH->Fill(0.5); return; } //**** //**** Check number of tracks //**** TClonesArray* tracks = dynamic_cast(fAOD->GetTracks()); //**** //**** Declaration of arrays and variables //**** // We use static array, not to fragment the memory AliAODJet recJets[kMaxJets]; Int_t nRecJets = 0; Int_t nTracks = 0; ////////////////////////////////////////////////// ///////// Get the reconstructed jets ///////////// ////////////////////////////////////////////////// nRecJets = aodRecJets->GetEntries(); nRecJets = TMath::Min(nRecJets,kMaxJets); nTracks = fAOD->GetNumberOfTracks(); for(int ir = 0;ir < nRecJets;++ir) { AliAODJet *tmp = dynamic_cast(aodRecJets->At(ir)); if(!tmp)continue; recJets[ir] = *tmp; cout << "recJets[" << ir << "].Eta(): " << recJets[ir].Eta() << ", recJets[" << ir <<"].Phi(): " << recJets[ir].Phi() << ", recJets[" << ir << "].E(): " << recJets[ir].E() << endl; } if(nRecJets>1) { Float_t detaJ = recJets[0].Eta() - recJets[1].Eta(); Float_t dphiJ = recJets[0].Phi() - recJets[1].Phi(); Float_t detJ = recJets[0].Pt() - recJets[1].Pt(); cout << "detaJ: " << detaJ << ", dphiJ: " << dphiJ << ", detJ: " << detJ << endl; } // Get vertex information fvertexXY->Fill(pvtx->GetX(),pvtx->GetY()); fvertexZ->Fill(pvtx->GetZ()); ////////////////////////////////////////////////// ////////////// TRACK QUALITY ASSURANCE /////////// TO BE OPTIMISED!! ////////////////////////////////////////////////// Int_t evtMult = 0; for(Int_t it=0; itAt(it); Float_t etaT = aodTrack->Eta(); Float_t phiT = aodTrack->Phi(); Float_t ptT = aodTrack->Pt(); phiT = ((phiT < 0) ? phiT + 2 * TMath::Pi() : phiT); // cout << "etaT: " << etaT << ", phiT: " << phiT << endl; fptAllTracks->Fill(ptT); fetaAllTracks->Fill(etaT); fphiAllTracks->Fill(phiT); fetaphiptAllTracks->Fill(etaT,phiT,ptT); fetaphiAllTracks->Fill(etaT,phiT,1); UInt_t status = aodTrack->GetStatus(); for(Int_t i=0; i=farrayPtTrigmin[i] && ptTFill(ptT); fetaTracks[i]->Fill(etaT); fphiTracks[i]->Fill(phiT); fNPtTrig[i]->Fill(0.5); // Compute deta/dphi Float_t etaT2 = 0.; Float_t phiT2 = 0.; Float_t ptT2 = 0.; Float_t detaT = 0.; Float_t dphiT = 0.; for(Int_t it2 = 0; it2< nTracks; it2++) { AliAODTrack* aodTrack2 = (AliAODTrack*)tracks->At(it2); etaT2 = aodTrack2->Eta(); phiT2 = aodTrack2->Phi(); ptT2 = aodTrack2->Pt(); phiT2 = ((phiT2 < 0) ? phiT2 + 2 * TMath::Pi() : phiT2); // cout << "etaT2: " << etaT2 << ", phiT2: " << phiT2 << endl; if(ptT2 > 2.*i+4.) continue; if(it2==it) continue; detaT = etaT - etaT2; dphiT = phiT - phiT2; if (dphiT > TMath::Pi()) dphiT = (-TMath::Pi() +TMath::Abs(dphiT - TMath::Pi())); if (dphiT < -1.0*TMath::Pi()) dphiT = (TMath::Pi() - TMath::Abs(dphiT + TMath::Pi())); fdetaTracks[i]->Fill(detaT); fdphiTracks[i]->Fill(dphiT); fdetadphiTracks[i]->Fill(detaT,dphiT,1); } fetaphiptTracks[i]->Fill(etaT,phiT,ptT); fetaphiTracks[i]->Fill(etaT,phiT,1); } } // End loop over trigger ranges if (status == 0) continue; if((fFilterMask>0)&&!(aodTrack->TestFilterBit(fFilterMask))) continue; fptAllTracksCut->Fill(ptT); fetaAllTracksCut->Fill(etaT); fphiAllTracksCut->Fill(phiT); fetaphiptAllTracksCut->Fill(etaT,phiT,ptT); fetaphiAllTracksCut->Fill(etaT,phiT,1); if(ptT > 0.150 && TMath::Abs(etaT) < 0.9) evtMult++; } // end loop over tracks fEvtMult->Fill(evtMult); ////////////////////////////////////////////////// ///////////////// MONOJET PART /////////////////// ////////////////////////////////////////////////// if (nRecJets == 0) return; Double_t jetEnergy = recJets[0].E(); Int_t goodBin = 999; for (Int_t i1 = 0; i1 < fnEBin; i1++) { if (jetEnergy < farrayEmax[i1] && jetEnergy >= farrayEmin[i1]) { goodBin = i1; continue; } } fptLeadingJet->Fill(recJets[0].Pt()); fetaLeadingJet->Fill(recJets[0].Eta()); fphiLeadingJet->Fill(recJets[0].Phi()); for(Int_t ij=0; ijFill(recJets[ij].Pt()); fetaJet->Fill(recJets[ij].Eta()); fphiJet->Fill(recJets[ij].Phi()); } // Get track ref TRefArray* ref = recJets[0].GetRefTracks(); for(Int_t it=0; itGetEntries(); it++) { Float_t ptTrack = ((AliVTrack*)ref->At(it))->Pt(); fPtvsEtaJet->Fill(recJets[0].Eta(),ptTrack); fNpvsEtaJet->Fill(recJets[0].Eta(),ref->GetEntries()); fNpevtvsEtaJet->Fill(recJets[0].Eta(),evtMult); fPtvsPtJet->Fill(recJets[0].Pt(),ptTrack); fNpvsPtJet->Fill(recJets[0].Pt(),ref->GetEntries()); fNpevtvsPtJet->Fill(recJets[0].Pt(),evtMult); fPtvsPtJet1D->Fill(recJets[0].Pt(),ptTrack); fNpvsPtJet1D->Fill(recJets[0].Pt(),ref->GetEntries()); fNpevtvsPtJet1D->Fill(recJets[0].Pt(),evtMult); } FillMonoJetH(goodBin, recJets, tracks); ////////////////////////////////////////////////// ////////////////// DIJET PART //////////////////// ////////////////////////////////////////////////// // UNDER CONSTRUCTION PostData(1, fHistList); } //####################################################################### void AliAnalysisTaskFragmentationFunction::Terminate(Option_t */*option*/) { // Terminate analysis // if (fDebug > 1) printf("AnalysisDiJets: Terminate() \n"); printf("Number of events with vertex out of bound: %d", fNBadRuns); } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// void AliAnalysisTaskFragmentationFunction::DefineJetH() { /////////////////////////////////////// HISTOGRAMS FIRST JET fEtaMonoJet1H = new TH1F*[fnEBin+1]; fPhiMonoJet1H = new TH1F*[fnEBin+1]; fPtMonoJet1H = new TH1F*[fnEBin+1]; fEMonoJet1H = new TH1F*[fnEBin+1]; fdNdXiMonoJet1H = new TH1F**[fnEBin+1]; fdNdPtMonoJet1H = new TH1F**[fnEBin+1]; fdNdZMonoJet1H = new TH1F**[fnEBin+1]; fdNdThetaMonoJet1H = new TH1F**[fnEBin+1]; fdNdcosThetaMonoJet1H = new TH1F**[fnEBin+1]; fdNdkTMonoJet1H = new TH1F**[fnEBin+1]; fdNdpTvsZMonoJet1H = new TH1F**[fnEBin+1]; fShapeMonoJet1H = new TH1F**[fnEBin+1]; fNMonoJet1sH = new TH1F**[fnEBin+1]; fThetaPtPartMonoJet1H = new TH2F**[fnEBin+1]; fcosThetaPtPartMonoJet1H = new TH2F**[fnEBin+1]; fkTPtPartMonoJet1H = new TH2F**[fnEBin+1]; fThetaPtJetMonoJet1H = new TH2F**[fnEBin+1]; fcosThetaPtJetMonoJet1H = new TH2F**[fnEBin+1]; fkTPtJetMonoJet1H = new TH2F**[fnEBin+1]; fpTPtJetMonoJet1H = new TH2F**[fnEBin+1]; for (Int_t iEbin=0;iEbin 150 MeV/c, |#eta| < 0.9",100,0.,100.); fEvtMultvsJetPt = new TH2F("fEvtMultvsJetPt","Event multiplicity vs pT_{jet}",60,0.,60.,100,0.,100.); fPtvsEtaJet = new TH2F("fPtvsEtaJet","Pt vs #eta_{jet}",20,-1.,1.,60,0.,60.); fNpvsEtaJet = new TH2F("fNpvsEtaJet","N_{part} inside jet vs #eta_{jet}",20,-1.,1.,20,0,20); fNpevtvsEtaJet = new TH2F("fNpevtvsEtaJet","N_{part} in evt vs #eta_{jet}",20,-1.,1.,90,0,90); fPtvsPtJet = new TH2F("fPtvsPtJet","Pt vs #p_{Tjet}",60,0.,60.,60,0.,60.); fNpvsPtJet = new TH2F("fNpvsPtJet","N_{part} inside jet vs #pt_{Tjet}",60,0.,60.,20,0,20); fNpevtvsPtJet = new TH2F("fNpevtvsPtJet","N_{part} in evt vs #pt_{Tjet}",60,0.,60.,90,0,90); fPtvsPtJet1D = new TH1F("fPtvsPtJet1D","Pt vs #p_{Tjet}",60,0.,60.); fNpvsPtJet1D = new TH1F("fNpvsPtJet1D","N_{part} inside jet vs #pt_{Tjet}",60,0.,60.); fNpevtvsPtJet1D = new TH1F("fNpevtvsPtJet1D","N_{part} in evt vs #pt_{Tjet}",60,0.,60.); fptLeadingJet = new TH1F("fptLeadingJet","Pt leading Jet [GeV/c]",60,0.,60.); fetaLeadingJet = new TH1F("fetaLeadingJet","#eta leading jet",20,-1.,1.); fphiLeadingJet = new TH1F("fphiLeadingJet","#phi leading jet",12,0.,2*TMath::Pi()); fptJet = new TH1F("fptJet","Pt Jets [GeV/c]",60,0.,60.); fetaJet = new TH1F("fetaJet","#eta jet",20,-1.,1.); fphiJet = new TH1F("fphiJet","#phi jet",12,0.,2*TMath::Pi()); fNBadRunsH = new TH1F("fNBadRunsH","Number of events with Z vertex out of range", 1, 0., 1.); SetProperties(fvertexXY, "vtx X", "vtx Y"); SetProperties(fvertexZ, "vtx Z", "Count"); SetProperties(fEvtMult, "N_{part} / event", "Count"); SetProperties(fEvtMultvsJetPt, "p_{T jet}", "Event multiplicity"); SetProperties(fPtvsEtaJet, "#eta_{leading jet}", "p_{T} part [GeV/c]"); SetProperties(fNpvsEtaJet, "#eta_{leading jet}", "N_{part} in leading jet"); SetProperties(fNpevtvsEtaJet, "#eta_{leading jet}", "N_{part} in event"); SetProperties(fPtvsPtJet, "#p_{T leading jet}", "p_{T} part [GeV/c]"); SetProperties(fNpvsPtJet, "#p_{T leading jet}", "N_{part} in leading jet"); SetProperties(fNpevtvsPtJet, "#p_{T leading jet}", "N_{part} in event"); SetProperties(fPtvsPtJet1D, "#p_{T leading jet}", " part [GeV/c]"); SetProperties(fNpvsPtJet1D, "#p_{T leading jet}", " in leading jet"); SetProperties(fNpevtvsPtJet1D, "#p_{T leading jet}", " in event"); SetProperties(fptLeadingJet, "p_{T} leading jet", "dN/dp_{T} leading jet"); SetProperties(fetaLeadingJet, "#eta leading jet", "dN/d#eta leading jet"); SetProperties(fphiLeadingJet, "#phi leading jet", "dN/d#phi leading jet"); SetProperties(fptJet, "p_{T} jet [GeV/c]", "dN/dp_{T}"); SetProperties(fetaJet, "#eta jet", "dN/d#eta"); SetProperties(fphiJet, "#phi jet", "dN/d#phi"); } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// void AliAnalysisTaskFragmentationFunction::FillMonoJetH(Int_t goodBin, AliAODJet* recJets, TClonesArray* tracks) { if (goodBin == 999) return; Int_t nTracks = tracks->GetEntries(); Float_t xi,t1,ene,dr2,deta2,dphi2, z, cosTheta, theta, kt; Bool_t jetOk1 = 0; Bool_t jetOk2 = 0; Bool_t jetOk3 = 0; Bool_t jetOk4 = 0; Bool_t jetOk5 = 0; Bool_t jetOk6 = 0; Bool_t jetOk7 = 0; Bool_t jetOk8 = 0; Bool_t jetOk9 = 0; Bool_t jetOk10 = 0; fEtaMonoJet1H[goodBin]->Fill(recJets[0].Eta()); fPhiMonoJet1H[goodBin]->Fill(recJets[0].Phi()); fPtMonoJet1H[goodBin]->Fill(recJets[0].Pt()); fEMonoJet1H[goodBin]->Fill(recJets[0].E()); Int_t mult = 0; for(Int_t it=0; itAt(it); // Apply track cuts UInt_t status = aodTrack->GetStatus(); if (status == 0) continue; if((fFilterMask>0)&&!(aodTrack->TestFilterBit(fFilterMask)))continue; mult++; Float_t etaT = aodTrack->Eta(); Float_t phiT = aodTrack->Phi(); Float_t ptT = aodTrack->Pt(); // For Theta distribution Float_t pxT = aodTrack->Px(); Float_t pyT = aodTrack->Py(); Float_t pzT = aodTrack->Pz(); Float_t pT = aodTrack->P(); // Compute theta cosTheta = (pxT*recJets[0].Px()+pyT*recJets[0].Py()+pzT*recJets[0].Pz())/(pT*recJets[0].P()); theta = TMath::ACos(cosTheta); // Compute xi deta2 = etaT - recJets[0].Eta(); dphi2 = phiT - recJets[0].Phi(); if (dphi2 < -TMath::Pi()) dphi2= -dphi2 - 2.0 * TMath::Pi(); if (dphi2 > TMath::Pi()) dphi2 = 2.0 * TMath::Pi() - dphi2; dr2 = TMath::Sqrt(deta2 * deta2 + dphi2 * dphi2); t1 = TMath::Tan(2.0*TMath::ATan(TMath::Exp(-etaT))); ene = ptT*TMath::Sqrt(1.+1./(t1*t1)); xi = (Float_t) TMath::Log(recJets[0].E()/ptT); // Compute z z = (Double_t)(ptT/recJets[0].E()); // Compute kT/jT TVector3 partP; TVector3 jetP; jetP[0] = recJets[0].Px(); jetP[1] = recJets[0].Py(); jetP[2] = recJets[0].Pz(); partP.SetPtEtaPhi(ptT,etaT,phiT); kt = TMath::Sin(partP.Angle(jetP))*partP.Mag(); // Compute Jet shape for(Int_t i2 = 0; i2 < fnRBin; i2++) { if ((dr2 fPartPtCut)) { if (i2 == 0) jetOk1 = 1; if (i2 == 1) jetOk2 = 1; if (i2 == 2) jetOk3 = 1; if (i2 == 3) jetOk4 = 1; if (i2 == 4) jetOk5 = 1; if (i2 == 5) jetOk6 = 1; if (i2 == 6) jetOk7 = 1; if (i2 == 7) jetOk8 = 1; if (i2 == 8) jetOk9 = 1; if (i2 == 9) jetOk10 = 1; fdNdXiMonoJet1H[goodBin][i2]->Fill(xi); fdNdPtMonoJet1H[goodBin][i2]->Fill(ptT); fdNdZMonoJet1H[goodBin][i2]->Fill(z); fdNdThetaMonoJet1H[goodBin][i2]->Fill(theta); fdNdcosThetaMonoJet1H[goodBin][i2]->Fill(cosTheta); fdNdkTMonoJet1H[goodBin][i2]->Fill(kt); fdNdpTvsZMonoJet1H[goodBin][i2]->Fill(z,1/((fPthadHBinMax-fPthadHBinMin)/fnPthadHBin)); fThetaPtPartMonoJet1H[goodBin][i2]->Fill(ptT,theta); fcosThetaPtPartMonoJet1H[goodBin][i2]->Fill(ptT,cosTheta); fkTPtPartMonoJet1H[goodBin][i2]->Fill(ptT,kt); fThetaPtJetMonoJet1H[goodBin][i2]->Fill(recJets[0].Pt(),theta); fcosThetaPtJetMonoJet1H[goodBin][i2]->Fill(recJets[0].Pt(),cosTheta); fkTPtJetMonoJet1H[goodBin][i2]->Fill(recJets[0].Pt(),kt); fpTPtJetMonoJet1H[goodBin][i2]->Fill(recJets[0].Pt(),ptT); } } } fEvtMultvsJetPt->Fill(recJets[0].Pt(),mult); if (jetOk1) fNMonoJet1sH[goodBin][0]->Fill(0.5); if (jetOk2) fNMonoJet1sH[goodBin][1]->Fill(0.5); if (jetOk3) fNMonoJet1sH[goodBin][2]->Fill(0.5); if (jetOk4) fNMonoJet1sH[goodBin][3]->Fill(0.5); if (jetOk5) fNMonoJet1sH[goodBin][4]->Fill(0.5); if (jetOk6) fNMonoJet1sH[goodBin][5]->Fill(0.5); if (jetOk7) fNMonoJet1sH[goodBin][6]->Fill(0.5); if (jetOk8) fNMonoJet1sH[goodBin][7]->Fill(0.5); if (jetOk9) fNMonoJet1sH[goodBin][8]->Fill(0.5); if (jetOk10) fNMonoJet1sH[goodBin][9]->Fill(0.5); } ////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////// void AliAnalysisTaskFragmentationFunction::SetProperties(TH1* h,const char* x, const char* y) { //Set properties of histos (x and y title and error propagation) h->SetXTitle(x); h->SetYTitle(y); h->GetXaxis()->SetTitleColor(1); h->GetYaxis()->SetTitleColor(1); h->Sumw2(); } ////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////