1 /**************************************************************************
2 * Author: Panos Christakoglou. *
3 * Contributors are mentioned in the code where appropriate. *
5 * Permission to use, copy, modify and distribute this software and its *
6 * documentation strictly for non-commercial purposes is hereby granted *
7 * without fee, provided that the above copyright notice appears in all *
8 * copies and that both the copyright notice and this permission notice *
9 * appear in the supporting documentation. The authors make no claims *
10 * about the suitability of this software for any purpose. It is *
11 * provided "as is" without express or implied warranty. *
12 **************************************************************************/
16 //-----------------------------------------------------------------
17 // AliTagCreator class
18 // This is the class to deal with the tag creation (post process)
19 // Origin: Panos Christakoglou, UOA-CERN, Panos.Christakoglou@cern.ch
20 //-----------------------------------------------------------------
23 #include <Riostream.h>
29 #include <TLorentzVector.h>
33 #include <TGridResult.h>
36 #include "AliRunTag.h"
37 #include "AliEventTag.h"
39 #include "AliESDEvent.h"
40 #include "AliESDVertex.h"
43 #include "AliAODEvent.h"
44 #include "AliAODVertex.h"
45 #include "AliAODTrack.h"
47 #include "AliTagCreator.h"
50 ClassImp(AliTagCreator)
53 //______________________________________________________________________________
54 AliTagCreator::AliTagCreator() :
56 fSE("ALICE::CERN::se"),
60 //==============Default constructor for a AliTagCreator==================
63 //______________________________________________________________________________
64 AliTagCreator::~AliTagCreator() {
65 //================Default destructor for a AliTagCreator=======================
68 //______________________________________________________________________________
69 void AliTagCreator::SetStorage(Int_t storage) {
70 // Sets correctly the storage: 0 for local, 1 for GRID
73 AliInfo(Form("Tags will be stored locally...."));
75 AliInfo(Form("Tags will be stored in the grid...."));
76 if((fStorage != 0)&&(fStorage != 1))
78 AliInfo(Form("Storage was not properly set!!!"));
84 //______________________________________________________________________________
85 Bool_t AliTagCreator::ReadGridCollection(TGridResult *fresult) {
86 // Reads the entry of the TGridResult and creates the tags
87 Int_t nEntries = fresult->GetEntries();
96 for(Int_t i = 0; i < nEntries; i++) {
97 alienUrl = fresult->GetKey(i,"turl");
98 guid = fresult->GetKey(i,"guid");
99 if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
100 md5 = fresult->GetKey(i,"md5");
101 turl = fresult->GetKey(i,"turl");
102 if(md5 && !strlen(guid)) md5 = 0;
103 if(guid && !strlen(guid)) guid = 0;
105 TFile *f = TFile::Open(alienUrl,"READ");
106 CreateTag(f,guid,md5,turl,size,counter);
115 //______________________________________________________________________________
116 Bool_t AliTagCreator::ReadLocalCollection(const char *localpath) {
117 // Checks the different subdirs of the given local path and in the
118 // case where it finds an AliESDs.root file it creates the tags
120 void *dira = gSystem->OpenDirectory(localpath);
122 const char * dirname = 0x0;
123 const char * filename = 0x0;
124 const char * pattern = "AliESDs.root";
127 while((dirname = gSystem->GetDirEntry(dira))) {
128 sprintf(fPath,"%s/%s",localpath,dirname);
129 void *dirb = gSystem->OpenDirectory(fPath);
130 while((filename = gSystem->GetDirEntry(dirb))) {
131 if(strstr(filename,pattern)) {
132 TString fESDFileName;
133 fESDFileName = fPath;
135 fESDFileName += pattern;
136 TFile *f = TFile::Open(fESDFileName,"READ");
137 CreateTag(f,fESDFileName,counter);
143 }//child directory's entry loop
144 }//parent directory's entry loop
149 //______________________________________________________________________________
150 Bool_t AliTagCreator::ReadCAFCollection(const char *filename) {
151 // Temporary solution for CAF: Takes as an input the ascii file that
152 // lists the ESDs stored in the SE of the CAF and creates the tags.
154 // Open the input stream
160 // Read the input list of files and add them to the chain
163 if (!esdfile.Contains("root")) continue; // protection
164 TFile *f = TFile::Open(esdfile,"READ");
165 CreateTag(f,esdfile,counter);
176 //__________________________________________________________________________
177 Bool_t AliTagCreator::MergeTags() {
178 //Merges the tags and stores the merged tag file
179 //locally if fStorage=0 or in the grid if fStorage=1
180 AliInfo(Form("Merging tags....."));
181 TChain *fgChain = new TChain("T");
184 const char * tagPattern = "tag";
185 // Open the working directory
186 void * dirp = gSystem->OpenDirectory(gSystem->pwd());
187 const char * name = 0x0;
188 // Add all files matching *pattern* to the chain
189 while((name = gSystem->GetDirEntry(dirp))) {
190 if (strstr(name,tagPattern)) fgChain->Add(name);
192 AliInfo(Form("Chained tag files: %d",fgChain->GetEntries()));
195 else if(fStorage == 1) {
196 TString alienLocation = gGrid->Pwd();
197 alienLocation += fgridpath.Data();
198 alienLocation += "/";
200 TGridResult *tagresult = gGrid->Query(alienLocation,"*tag.root","","");
201 Int_t nEntries = tagresult->GetEntries();
202 for(Int_t i = 0; i < nEntries; i++) {
203 TString alienUrl = tagresult->GetKey(i,"turl");
204 fgChain->Add(alienUrl);
206 AliInfo(Form("Chained tag files: %d",fgChain->GetEntries()));
209 AliRunTag *tag = new AliRunTag;
210 fgChain->SetBranchAddress("AliTAG",&tag);
211 fgChain->GetEntry(0);
212 TString localFileName = "Run"; localFileName += tag->GetRunId();
213 localFileName += ".Merged"; localFileName += ".ESD.tag.root";
215 TString filename = 0x0;
218 filename = localFileName.Data();
219 AliInfo(Form("Writing merged tags to local file: %s",filename.Data()));
221 else if(fStorage == 1) {
222 TString alienFileName = "/alien";
223 alienFileName += gGrid->Pwd();
224 alienFileName += fgridpath.Data();
225 alienFileName += "/";
226 alienFileName += localFileName;
227 alienFileName += "?se=";
228 alienFileName += fSE.Data();
229 filename = alienFileName.Data();
230 AliInfo(Form("Writing merged tags to grid file: %s",filename.Data()));
233 fgChain->Merge(filename);
234 gSystem->Exec("rm Run*.Event*");
239 //__________________________________________________________________________
240 Bool_t AliTagCreator::MergeTags(TGridResult *result) {
241 //Merges the tags that are listed in the TGridResult
242 AliInfo(Form("Merging tags....."));
243 TChain *fgChain = new TChain("T");
245 Int_t nEntries = result->GetEntries();
248 for(Int_t i = 0; i < nEntries; i++) {
249 alienUrl = result->GetKey(i,"turl");
250 fgChain->Add(alienUrl);
252 AliInfo(Form("Chained tag files: %d",fgChain->GetEntries()));
253 AliRunTag *tag = new AliRunTag;
254 fgChain->SetBranchAddress("AliTAG",&tag);
255 fgChain->GetEntry(0);
257 TString localFileName = "Run"; localFileName += tag->GetRunId();
258 localFileName += ".Merged"; localFileName += ".ESD.tag.root";
260 TString filename = 0x0;
263 filename = localFileName.Data();
264 AliInfo(Form("Writing merged tags to local file: %s",filename.Data()));
266 else if(fStorage == 1) {
267 TString alienFileName = "/alien";
268 alienFileName += gGrid->Pwd();
269 alienFileName += fgridpath.Data();
270 alienFileName += "/";
271 alienFileName += localFileName;
272 alienFileName += "?se=";
273 alienFileName += fSE.Data();
274 filename = alienFileName.Data();
275 AliInfo(Form("Writing merged tags to grid file: %s",filename.Data()));
278 fgChain->Merge(filename);
283 //_____________________________________________________________________________
284 void AliTagCreator::CreateTag(TFile* file, const char *guid, const char *md5, const char *turl, Long64_t size, Int_t Counter) {
285 //private method that creates tag files
286 TString fguid = guid;
288 TString fturl = turl;
292 Double_t fMUONMASS = 0.105658369;
295 Double_t fThetaX, fThetaY, fPyz, fChisquare;
296 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
298 TLorentzVector fEPvector;
300 Float_t fZVertexCut = 10.0;
301 Float_t fRhoVertexCut = 2.0;
303 Float_t fLowPtCut = 1.0;
304 Float_t fHighPtCut = 3.0;
305 Float_t fVeryHighPtCut = 10.0;
308 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
310 // Creates the tags for all the events in a given ESD file
311 Bool_t fIsSim = kTRUE;
313 Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
314 Int_t nPos, nNeg, nNeutr;
315 Int_t nK0s, nNeutrons, nPi0s, nGamas;
316 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
317 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
318 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
319 Float_t maxPt = .0, meanPt = .0, totalP = .0;
321 Int_t iRunNumber = 0;
324 AliRunTag *tag = new AliRunTag();
325 AliEventTag *evTag = new AliEventTag();
326 TTree ttag("T","A Tree with event tags");
327 TBranch * btag = ttag.Branch("AliTAG", &tag);
328 btag->SetCompressionLevel(9);
330 AliInfo(Form("Creating the tags......."));
332 Int_t firstEvent = 0,lastEvent = 0;
333 TTree *t = (TTree*) file->Get("esdTree");
334 AliESDEvent *esd = new AliESDEvent();
335 esd->ReadFromTree(t);
338 Int_t iInitRunNumber = esd->GetRunNumber();
340 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
341 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
369 t->GetEntry(iEventNumber);
370 iRunNumber = esd->GetRunNumber();
371 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
372 const AliESDVertex * vertexIn = esd->GetVertex();
373 fVertexName = vertexIn->GetName();
374 if(fVertexName == "default") fVertexflag = 0;
376 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
377 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
378 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
379 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
380 UInt_t status = esdTrack->GetStatus();
382 //select only tracks with ITS refit
383 if ((status&AliESDtrack::kITSrefit)==0) continue;
384 //select only tracks with TPC refit
385 if ((status&AliESDtrack::kTPCrefit)==0) continue;
387 //select only tracks with the "combined PID"
388 if ((status&AliESDtrack::kESDpid)==0) continue;
390 esdTrack->GetPxPyPz(p);
391 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
392 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
395 if(fPt > maxPt) maxPt = fPt;
397 if(esdTrack->GetSign() > 0) {
399 if(fPt > fLowPtCut) nCh1GeV++;
400 if(fPt > fHighPtCut) nCh3GeV++;
401 if(fPt > fVeryHighPtCut) nCh10GeV++;
403 if(esdTrack->GetSign() < 0) {
405 if(fPt > fLowPtCut) nCh1GeV++;
406 if(fPt > fHighPtCut) nCh3GeV++;
407 if(fPt > fVeryHighPtCut) nCh10GeV++;
409 if(esdTrack->GetSign() == 0) nNeutr++;
413 esdTrack->GetESDpid(prob);
416 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
417 if(rcc == 0.0) continue;
420 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
423 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
425 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
427 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
429 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
431 if(fPt > fLowPtCut) nEl1GeV++;
432 if(fPt > fHighPtCut) nEl3GeV++;
433 if(fPt > fVeryHighPtCut) nEl10GeV++;
441 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
442 // loop over all reconstructed tracks (also first track of combination)
443 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
444 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
445 if (muonTrack == 0x0) continue;
447 // Coordinates at vertex
448 fZ = muonTrack->GetZ();
449 fY = muonTrack->GetBendingCoor();
450 fX = muonTrack->GetNonBendingCoor();
452 fThetaX = muonTrack->GetThetaX();
453 fThetaY = muonTrack->GetThetaY();
455 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
456 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
457 fPxRec = fPzRec * TMath::Tan(fThetaX);
458 fPyRec = fPzRec * TMath::Tan(fThetaY);
459 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
461 //ChiSquare of the track if needed
462 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
463 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
464 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
466 // total number of muons inside a vertex cut
467 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
469 if(fEPvector.Pt() > fLowPtCut) {
471 if(fEPvector.Pt() > fHighPtCut) {
473 if (fEPvector.Pt() > fVeryHighPtCut) {
481 // Fill the event tags
482 if(ntrack != 0) meanPt = meanPt/ntrack;
484 evTag->SetEventId(iEventNumber+1);
485 evTag->SetGUID(fguid);
487 evTag->SetTURL(fturl);
488 evTag->SetSize(size);
489 evTag->SetVertexX(vertexIn->GetXv());
490 evTag->SetVertexY(vertexIn->GetYv());
491 evTag->SetVertexZ(vertexIn->GetZv());
492 evTag->SetVertexZError(vertexIn->GetZRes());
493 evTag->SetVertexFlag(fVertexflag);
495 evTag->SetT0VertexZ(esd->GetT0zVertex());
497 evTag->SetTriggerMask(esd->GetTriggerMask());
498 evTag->SetTriggerCluster(esd->GetTriggerCluster());
500 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
501 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
502 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
503 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
504 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
505 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
508 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
509 evTag->SetNumOfPosTracks(nPos);
510 evTag->SetNumOfNegTracks(nNeg);
511 evTag->SetNumOfNeutrTracks(nNeutr);
513 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
514 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
515 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
516 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
518 evTag->SetNumOfProtons(nProtons);
519 evTag->SetNumOfKaons(nKaons);
520 evTag->SetNumOfPions(nPions);
521 evTag->SetNumOfMuons(nMuons);
522 evTag->SetNumOfElectrons(nElectrons);
523 evTag->SetNumOfPhotons(nGamas);
524 evTag->SetNumOfPi0s(nPi0s);
525 evTag->SetNumOfNeutrons(nNeutrons);
526 evTag->SetNumOfKaon0s(nK0s);
528 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
529 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
530 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
531 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
532 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
533 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
534 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
535 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
536 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
538 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
539 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
541 evTag->SetTotalMomentum(totalP);
542 evTag->SetMeanPt(meanPt);
543 evTag->SetMaxPt(maxPt);
545 tag->SetRunId(iInitRunNumber);
546 if(fIsSim) tag->SetDataType(0);
547 else tag->SetDataType(1);
548 tag->AddEventTag(*evTag);
550 lastEvent = iNumberOfEvents;
557 TString localFileName = "Run"; localFileName += tag->GetRunId();
558 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
559 localFileName += ".ESD.tag.root";
564 fileName = localFileName.Data();
565 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
567 else if(fStorage == 1) {
568 TString alienLocation = "/alien";
569 alienLocation += gGrid->Pwd();
570 alienLocation += fgridpath.Data();
571 alienLocation += "/";
572 alienLocation += localFileName;
573 alienLocation += "?se=";
574 alienLocation += fSE.Data();
575 fileName = alienLocation.Data();
576 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
579 TFile* ftag = TFile::Open(fileName, "recreate");
590 //_____________________________________________________________________________
591 void AliTagCreator::CreateTag(TFile* file, const char *filepath, Int_t Counter) {
592 //private method that creates tag files
596 Double_t fMUONMASS = 0.105658369;
599 Double_t fThetaX, fThetaY, fPyz, fChisquare;
600 Double_t fPxRec, fPyRec, fPzRec, fEnergy;
602 TLorentzVector fEPvector;
604 Float_t fZVertexCut = 10.0;
605 Float_t fRhoVertexCut = 2.0;
607 Float_t fLowPtCut = 1.0;
608 Float_t fHighPtCut = 3.0;
609 Float_t fVeryHighPtCut = 10.0;
612 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
614 // Creates the tags for all the events in a given ESD file
615 Bool_t fIsSim = kTRUE;
617 Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
618 Int_t nPos, nNeg, nNeutr;
619 Int_t nK0s, nNeutrons, nPi0s, nGamas;
620 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
621 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
622 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
623 Float_t maxPt = .0, meanPt = .0, totalP = .0;
625 Int_t iRunNumber = 0;
628 AliRunTag *tag = new AliRunTag();
629 AliEventTag *evTag = new AliEventTag();
630 TTree ttag("T","A Tree with event tags");
631 TBranch * btag = ttag.Branch("AliTAG", &tag);
632 btag->SetCompressionLevel(9);
634 AliInfo(Form("Creating the tags......."));
636 Int_t firstEvent = 0,lastEvent = 0;
638 TTree *t = (TTree*) file->Get("esdTree");
639 AliESDEvent *esd = new AliESDEvent();
640 esd->ReadFromTree(t);
643 Int_t iInitRunNumber = esd->GetRunNumber();
645 Int_t iNumberOfEvents = (Int_t)t->GetEntries();
646 for (Int_t iEventNumber = 0; iEventNumber < iNumberOfEvents; iEventNumber++) {
674 t->GetEntry(iEventNumber);
675 iRunNumber = esd->GetRunNumber();
676 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
677 const AliESDVertex * vertexIn = esd->GetVertex();
678 fVertexName = vertexIn->GetName();
679 if(fVertexName == "default") fVertexflag = 0;
681 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
682 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
683 if(esdTrack->GetLabel() != 0) fIsSim = kTRUE;
684 else if(esdTrack->GetLabel() == 0) fIsSim = kFALSE;
685 UInt_t status = esdTrack->GetStatus();
687 //select only tracks with ITS refit
688 if ((status&AliESDtrack::kITSrefit)==0) continue;
689 //select only tracks with TPC refit
690 if ((status&AliESDtrack::kTPCrefit)==0) continue;
692 //select only tracks with the "combined PID"
693 if ((status&AliESDtrack::kESDpid)==0) continue;
695 esdTrack->GetPxPyPz(p);
696 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
697 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
700 if(fPt > maxPt) maxPt = fPt;
702 if(esdTrack->GetSign() > 0) {
704 if(fPt > fLowPtCut) nCh1GeV++;
705 if(fPt > fHighPtCut) nCh3GeV++;
706 if(fPt > fVeryHighPtCut) nCh10GeV++;
708 if(esdTrack->GetSign() < 0) {
710 if(fPt > fLowPtCut) nCh1GeV++;
711 if(fPt > fHighPtCut) nCh3GeV++;
712 if(fPt > fVeryHighPtCut) nCh10GeV++;
714 if(esdTrack->GetSign() == 0) nNeutr++;
718 esdTrack->GetESDpid(prob);
721 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
722 if(rcc == 0.0) continue;
725 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
728 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
730 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
732 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
734 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
736 if(fPt > fLowPtCut) nEl1GeV++;
737 if(fPt > fHighPtCut) nEl3GeV++;
738 if(fPt > fVeryHighPtCut) nEl10GeV++;
746 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
747 // loop over all reconstructed tracks (also first track of combination)
748 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
749 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
750 if (muonTrack == 0x0) continue;
752 // Coordinates at vertex
753 fZ = muonTrack->GetZ();
754 fY = muonTrack->GetBendingCoor();
755 fX = muonTrack->GetNonBendingCoor();
757 fThetaX = muonTrack->GetThetaX();
758 fThetaY = muonTrack->GetThetaY();
760 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
761 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
762 fPxRec = fPzRec * TMath::Tan(fThetaX);
763 fPyRec = fPzRec * TMath::Tan(fThetaY);
764 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
766 //ChiSquare of the track if needed
767 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
768 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
769 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
771 // total number of muons inside a vertex cut
772 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
774 if(fEPvector.Pt() > fLowPtCut) {
776 if(fEPvector.Pt() > fHighPtCut) {
778 if (fEPvector.Pt() > fVeryHighPtCut) {
786 // Fill the event tags
787 if(ntrack != 0) meanPt = meanPt/ntrack;
789 evTag->SetEventId(iEventNumber+1);
790 evTag->SetPath(filepath);
792 evTag->SetVertexX(vertexIn->GetXv());
793 evTag->SetVertexY(vertexIn->GetYv());
794 evTag->SetVertexZ(vertexIn->GetZv());
795 evTag->SetVertexZError(vertexIn->GetZRes());
796 evTag->SetVertexFlag(fVertexflag);
798 evTag->SetT0VertexZ(esd->GetT0zVertex());
800 evTag->SetTriggerMask(esd->GetTriggerMask());
801 evTag->SetTriggerCluster(esd->GetTriggerCluster());
803 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
804 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
805 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
806 evTag->SetZDCNeutron1Energy(esd->GetZDCN2Energy());
807 evTag->SetZDCProton1Energy(esd->GetZDCP2Energy());
808 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
811 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
812 evTag->SetNumOfPosTracks(nPos);
813 evTag->SetNumOfNegTracks(nNeg);
814 evTag->SetNumOfNeutrTracks(nNeutr);
816 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
817 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
818 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
819 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
821 evTag->SetNumOfProtons(nProtons);
822 evTag->SetNumOfKaons(nKaons);
823 evTag->SetNumOfPions(nPions);
824 evTag->SetNumOfMuons(nMuons);
825 evTag->SetNumOfElectrons(nElectrons);
826 evTag->SetNumOfPhotons(nGamas);
827 evTag->SetNumOfPi0s(nPi0s);
828 evTag->SetNumOfNeutrons(nNeutrons);
829 evTag->SetNumOfKaon0s(nK0s);
831 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
832 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
833 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
834 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
835 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
836 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
837 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
838 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
839 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
841 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
842 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
844 evTag->SetTotalMomentum(totalP);
845 evTag->SetMeanPt(meanPt);
846 evTag->SetMaxPt(maxPt);
848 tag->SetRunId(iInitRunNumber);
849 if(fIsSim) tag->SetDataType(0);
850 else tag->SetDataType(1);
851 tag->AddEventTag(*evTag);
853 lastEvent = iNumberOfEvents;
860 TString localFileName = "Run"; localFileName += tag->GetRunId();
861 localFileName += ".Event"; localFileName += firstEvent; localFileName += "_"; localFileName += lastEvent; localFileName += "."; localFileName += Counter;
862 localFileName += ".ESD.tag.root";
867 fileName = localFileName.Data();
868 AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
870 else if(fStorage == 1) {
871 TString alienLocation = "/alien";
872 alienLocation += gGrid->Pwd();
873 alienLocation += fgridpath.Data();
874 alienLocation += "/";
875 alienLocation += localFileName;
876 alienLocation += "?se=";
877 alienLocation += fSE.Data();
878 fileName = alienLocation.Data();
879 AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
882 TFile* ftag = TFile::Open(fileName, "recreate");
893 //_____________________________________________________________________________
894 void AliTagCreator::CreateESDTags(Int_t fFirstEvent, Int_t fLastEvent) {
896 Float_t lhcLuminosity = 0.0;
897 TString lhcState = "test";
898 UInt_t detectorMask = 0;
903 Double_t fMUONMASS = 0.105658369;
906 Double_t fThetaX, fThetaY, fPyz, fChisquare;
907 Double_t fPxRec,fPyRec, fPzRec, fEnergy;
909 TLorentzVector fEPvector;
911 Float_t fZVertexCut = 10.0;
912 Float_t fRhoVertexCut = 2.0;
914 Float_t fLowPtCut = 1.0;
915 Float_t fHighPtCut = 3.0;
916 Float_t fVeryHighPtCut = 10.0;
919 Double_t partFrac[5] = {0.01, 0.01, 0.85, 0.10, 0.05};
921 // Creates the tags for all the events in a given ESD file
923 Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
924 Int_t nPos, nNeg, nNeutr;
925 Int_t nK0s, nNeutrons, nPi0s, nGamas;
926 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
927 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
928 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
929 Float_t maxPt = .0, meanPt = .0, totalP = .0;
931 Int_t iRunNumber = 0;
932 TString fVertexName("default");
934 AliRunTag *tag = new AliRunTag();
935 AliEventTag *evTag = new AliEventTag();
936 TTree ttag("T","A Tree with event tags");
937 TBranch * btag = ttag.Branch("AliTAG", &tag);
938 btag->SetCompressionLevel(9);
940 AliInfo(Form("Creating the tags......."));
942 TFile *file = TFile::Open("AliESDs.root");
943 if (!file || !file->IsOpen()) {
944 AliError(Form("opening failed"));
949 TTree *b = (TTree*) file->Get("esdTree");
950 AliESDEvent *esd = new AliESDEvent();
951 esd->ReadFromTree(b);
953 b->GetEntry(fFirstEvent);
954 Int_t iInitRunNumber = esd->GetRunNumber();
956 Int_t iNumberOfEvents = (Int_t)b->GetEntries();
957 if(fLastEvent != -1) iNumberOfEvents = fLastEvent + 1;
958 for (Int_t iEventNumber = fFirstEvent; iEventNumber < iNumberOfEvents; iEventNumber++) {
986 b->GetEntry(iEventNumber);
987 iRunNumber = esd->GetRunNumber();
988 if(iRunNumber != iInitRunNumber) AliFatal("Inconsistency of run numbers in the AliESD!!!");
989 const AliESDVertex * vertexIn = esd->GetVertex();
990 if (!vertexIn) AliError("ESD has not defined vertex.");
991 if (vertexIn) fVertexName = vertexIn->GetName();
992 if(fVertexName != "default") fVertexflag = 1;
993 for (Int_t iTrackNumber = 0; iTrackNumber < esd->GetNumberOfTracks(); iTrackNumber++) {
994 AliESDtrack * esdTrack = esd->GetTrack(iTrackNumber);
995 UInt_t status = esdTrack->GetStatus();
997 //select only tracks with ITS refit
998 if ((status&AliESDtrack::kITSrefit)==0) continue;
999 //select only tracks with TPC refit
1000 if ((status&AliESDtrack::kTPCrefit)==0) continue;
1002 //select only tracks with the "combined PID"
1003 if ((status&AliESDtrack::kESDpid)==0) continue;
1005 esdTrack->GetPxPyPz(p);
1006 Double_t momentum = sqrt(pow(p[0],2) + pow(p[1],2) + pow(p[2],2));
1007 Double_t fPt = sqrt(pow(p[0],2) + pow(p[1],2));
1010 if(fPt > maxPt) maxPt = fPt;
1012 if(esdTrack->GetSign() > 0) {
1014 if(fPt > fLowPtCut) nCh1GeV++;
1015 if(fPt > fHighPtCut) nCh3GeV++;
1016 if(fPt > fVeryHighPtCut) nCh10GeV++;
1018 if(esdTrack->GetSign() < 0) {
1020 if(fPt > fLowPtCut) nCh1GeV++;
1021 if(fPt > fHighPtCut) nCh3GeV++;
1022 if(fPt > fVeryHighPtCut) nCh10GeV++;
1024 if(esdTrack->GetSign() == 0) nNeutr++;
1028 esdTrack->GetESDpid(prob);
1031 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1032 if(rcc == 0.0) continue;
1035 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1038 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1040 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1042 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1044 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1046 if(fPt > fLowPtCut) nEl1GeV++;
1047 if(fPt > fHighPtCut) nEl3GeV++;
1048 if(fPt > fVeryHighPtCut) nEl10GeV++;
1056 Int_t nMuonTracks = esd->GetNumberOfMuonTracks();
1057 // loop over all reconstructed tracks (also first track of combination)
1058 for (Int_t iTrack = 0; iTrack < nMuonTracks; iTrack++) {
1059 AliESDMuonTrack* muonTrack = esd->GetMuonTrack(iTrack);
1060 if (muonTrack == 0x0) continue;
1062 // Coordinates at vertex
1063 fZ = muonTrack->GetZ();
1064 fY = muonTrack->GetBendingCoor();
1065 fX = muonTrack->GetNonBendingCoor();
1067 fThetaX = muonTrack->GetThetaX();
1068 fThetaY = muonTrack->GetThetaY();
1070 fPyz = 1./TMath::Abs(muonTrack->GetInverseBendingMomentum());
1071 fPzRec = - fPyz / TMath::Sqrt(1.0 + TMath::Tan(fThetaY)*TMath::Tan(fThetaY));
1072 fPxRec = fPzRec * TMath::Tan(fThetaX);
1073 fPyRec = fPzRec * TMath::Tan(fThetaY);
1074 fCharge = Int_t(TMath::Sign(1.,muonTrack->GetInverseBendingMomentum()));
1076 //ChiSquare of the track if needed
1077 fChisquare = muonTrack->GetChi2()/(2.0 * muonTrack->GetNHit() - 5);
1078 fEnergy = TMath::Sqrt(fMUONMASS * fMUONMASS + fPxRec * fPxRec + fPyRec * fPyRec + fPzRec * fPzRec);
1079 fEPvector.SetPxPyPzE(fPxRec, fPyRec, fPzRec, fEnergy);
1081 // total number of muons inside a vertex cut
1082 if((TMath::Abs(fZ)<fZVertexCut) && (TMath::Sqrt(fY*fY+fX*fX)<fRhoVertexCut)) {
1084 if(fEPvector.Pt() > fLowPtCut) {
1086 if(fEPvector.Pt() > fHighPtCut) {
1088 if (fEPvector.Pt() > fVeryHighPtCut) {
1096 // Fill the event tags
1098 meanPt = meanPt/ntrack;
1100 evTag->SetEventId(iEventNumber+1);
1102 evTag->SetVertexX(vertexIn->GetXv());
1103 evTag->SetVertexY(vertexIn->GetYv());
1104 evTag->SetVertexZ(vertexIn->GetZv());
1105 evTag->SetVertexZError(vertexIn->GetZRes());
1107 evTag->SetVertexFlag(fVertexflag);
1109 evTag->SetT0VertexZ(esd->GetT0zVertex());
1111 evTag->SetTriggerMask(esd->GetTriggerMask());
1112 evTag->SetTriggerCluster(esd->GetTriggerCluster());
1114 evTag->SetZDCNeutron1Energy(esd->GetZDCN1Energy());
1115 evTag->SetZDCProton1Energy(esd->GetZDCP1Energy());
1116 evTag->SetZDCNeutron2Energy(esd->GetZDCN2Energy());
1117 evTag->SetZDCProton2Energy(esd->GetZDCP2Energy());
1118 evTag->SetZDCEMEnergy(esd->GetZDCEMEnergy());
1119 evTag->SetNumOfParticipants(esd->GetZDCParticipants());
1122 evTag->SetNumOfTracks(esd->GetNumberOfTracks());
1123 evTag->SetNumOfPosTracks(nPos);
1124 evTag->SetNumOfNegTracks(nNeg);
1125 evTag->SetNumOfNeutrTracks(nNeutr);
1127 evTag->SetNumOfV0s(esd->GetNumberOfV0s());
1128 evTag->SetNumOfCascades(esd->GetNumberOfCascades());
1129 evTag->SetNumOfKinks(esd->GetNumberOfKinks());
1130 evTag->SetNumOfPMDTracks(esd->GetNumberOfPmdTracks());
1132 evTag->SetNumOfProtons(nProtons);
1133 evTag->SetNumOfKaons(nKaons);
1134 evTag->SetNumOfPions(nPions);
1135 evTag->SetNumOfMuons(nMuons);
1136 evTag->SetNumOfElectrons(nElectrons);
1137 evTag->SetNumOfPhotons(nGamas);
1138 evTag->SetNumOfPi0s(nPi0s);
1139 evTag->SetNumOfNeutrons(nNeutrons);
1140 evTag->SetNumOfKaon0s(nK0s);
1142 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1143 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1144 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1145 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1146 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1147 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1148 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1149 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1150 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1152 evTag->SetNumOfPHOSClusters(esd->GetNumberOfPHOSClusters());
1153 evTag->SetNumOfEMCALClusters(esd->GetNumberOfEMCALClusters());
1155 evTag->SetTotalMomentum(totalP);
1156 evTag->SetMeanPt(meanPt);
1157 evTag->SetMaxPt(maxPt);
1159 tag->SetLHCTag(lhcLuminosity,lhcState);
1160 tag->SetDetectorTag(detectorMask);
1162 tag->SetRunId(iInitRunNumber);
1163 tag->AddEventTag(*evTag);
1165 if(fLastEvent == -1) lastEvent = (Int_t)b->GetEntries();
1166 else lastEvent = fLastEvent;
1172 sprintf(fileName, "Run%d.Event%d_%d.ESD.tag.root",
1173 tag->GetRunId(),fFirstEvent,lastEvent );
1174 AliInfo(Form("writing tags to file %s", fileName));
1175 AliDebug(1, Form("writing tags to file %s", fileName));
1177 TFile* ftag = TFile::Open(fileName, "recreate");
1186 //__________________________________________________________________________
1187 void AliTagCreator::CreateAODTags(Int_t fFirstEvent, Int_t fLastEvent) {
1188 //creates tag files for AODs
1190 Float_t fLowPtCut = 1.0;
1191 Float_t fHighPtCut = 3.0;
1192 Float_t fVeryHighPtCut = 10.0;
1195 Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
1197 // Creates the tags for all the events in a given ESD file
1199 Int_t nProtons, nKaons, nPions, nMuons, nElectrons;
1200 Int_t nPos, nNeg, nNeutr;
1201 Int_t nKinks, nV0s, nCascades;
1202 Int_t nK0s, nNeutrons, nPi0s, nGamas;
1203 Int_t nCh1GeV, nCh3GeV, nCh10GeV;
1204 Int_t nMu1GeV, nMu3GeV, nMu10GeV;
1205 Int_t nEl1GeV, nEl3GeV, nEl10GeV;
1206 Float_t maxPt = .0, meanPt = .0, totalP = .0;
1208 AliRunTag *tag = new AliRunTag();
1209 TTree ttag("T","A Tree with event tags");
1210 TBranch * btag = ttag.Branch("AliTAG", &tag);
1211 btag->SetCompressionLevel(9);
1213 //reading the esd tag file
1214 TChain *oldTagTree = new TChain("T");
1215 const char * tagPattern = "ESD.tag";
1216 // Open the working directory
1217 void * dirp = gSystem->OpenDirectory(gSystem->pwd());
1218 const char * name = 0x0;
1219 // Add all files matching *pattern* to the chain
1220 while((name = gSystem->GetDirEntry(dirp))) {
1221 if (strstr(name,tagPattern)) oldTagTree->Add(name);
1223 AliInfo(Form("Chained tag files: %d",oldTagTree->GetEntries()));
1225 //reading the esd tag file
1226 AliRunTag *oldtag = new AliRunTag();
1227 TString tagFilename;
1228 oldTagTree->SetBranchAddress("AliTAG",&oldtag);
1229 oldTagTree->GetEntry(0);
1230 tag->CopyStandardContent(oldtag);
1231 const TClonesArray *evTagList = oldtag->GetEventTags();
1233 AliInfo(Form("Creating the tags......."));
1235 TFile *file = TFile::Open("AliAOD.root");
1236 if (!file || !file->IsOpen()) {
1237 AliError(Form("opening failed"));
1241 TTree *aodTree = (TTree*)file->Get("AOD");
1242 AliAODEvent *aod = (AliAODEvent*)aodTree->GetUserInfo()->FindObject("AliAODEvent");
1243 TIter next(aod->GetList());
1246 Int_t lastEvent = 0;
1247 if(fLastEvent == -1) lastEvent = (Int_t)aodTree->GetEntries();
1248 else lastEvent = fLastEvent;
1250 while((el=(TNamed*)next()))
1251 aodTree->SetBranchAddress(el->GetName(),aod->GetList()->GetObjectRef(el));
1254 Int_t nEvents = aodTree->GetEntries();
1255 for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
1256 AliEventTag *evTag = (AliEventTag *)evTagList->At(iEventNumber);
1258 nPos = 0; nNeg = 0; nNeutr =0;
1259 nKinks = 0; nV0s = 0; nCascades = 0;
1260 nK0s = 0; nNeutrons = 0; nPi0s = 0; nGamas = 0;
1261 nProtons = 0; nKaons = 0; nPions = 0; nMuons = 0; nElectrons = 0;
1262 nCh1GeV = 0; nCh3GeV = 0; nCh10GeV = 0;
1263 nMu1GeV = 0; nMu3GeV = 0; nMu10GeV = 0;
1264 nEl1GeV = 0; nEl3GeV = 0; nEl10GeV = 0;
1265 maxPt = .0; meanPt = .0; totalP = .0;
1268 aodTree->GetEvent(iEventNumber);
1271 aod->GetStdContent();
1273 Int_t nTracks = aod->GetNTracks();
1274 // loop over vertices
1275 Int_t nVtxs = aod->GetNVertices();
1276 for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
1278 AliAODVertex *vertex = aod->GetVertex(nVtx);
1279 if(vertex->GetType() == 1) nKinks += 1;
1280 if(vertex->GetType() == 2) nV0s += 1;
1281 if(vertex->GetType() == 3) nCascades += 1;
1283 for (Int_t nTr = 0; nTr < nTracks; nTr++) {
1284 AliAODTrack *track = aod->GetTrack(nTr);
1286 Double_t fPt = track->Pt();
1287 if(fPt > maxPt) maxPt = fPt;
1288 if(track->Charge() > 0) {
1290 if(fPt > fLowPtCut) nCh1GeV++;
1291 if(fPt > fHighPtCut) nCh3GeV++;
1292 if(fPt > fVeryHighPtCut) nCh10GeV++;
1294 if(track->Charge() < 0) {
1296 if(fPt > fLowPtCut) nCh1GeV++;
1297 if(fPt > fHighPtCut) nCh3GeV++;
1298 if(fPt > fVeryHighPtCut) nCh10GeV++;
1300 if(track->Charge() == 0) nNeutr++;
1303 const Double32_t *prob = track->PID();
1305 for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
1306 if(rcc == 0.0) continue;
1309 for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
1312 if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
1314 if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
1316 if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
1318 if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
1320 if(fPt > fLowPtCut) nMu1GeV++;
1321 if(fPt > fHighPtCut) nMu3GeV++;
1322 if(fPt > fVeryHighPtCut) nMu10GeV++;
1325 if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
1327 if(fPt > fLowPtCut) nEl1GeV++;
1328 if(fPt > fHighPtCut) nEl3GeV++;
1329 if(fPt > fVeryHighPtCut) nEl10GeV++;
1332 totalP += track->P();
1336 // Fill the event tags
1338 meanPt = meanPt/ntrack;
1340 evTag->SetEventId(iEventNumber+1);
1342 evTag->SetNumOfTracks(nTracks);
1343 evTag->SetNumOfPosTracks(nPos);
1344 evTag->SetNumOfNegTracks(nNeg);
1345 evTag->SetNumOfNeutrTracks(nNeutr);
1347 evTag->SetNumOfV0s(nV0s);
1348 evTag->SetNumOfCascades(nCascades);
1349 evTag->SetNumOfKinks(nKinks);
1351 evTag->SetNumOfProtons(nProtons);
1352 evTag->SetNumOfKaons(nKaons);
1353 evTag->SetNumOfPions(nPions);
1354 evTag->SetNumOfMuons(nMuons);
1355 evTag->SetNumOfElectrons(nElectrons);
1356 evTag->SetNumOfPhotons(nGamas);
1357 evTag->SetNumOfPi0s(nPi0s);
1358 evTag->SetNumOfNeutrons(nNeutrons);
1359 evTag->SetNumOfKaon0s(nK0s);
1361 evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
1362 evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
1363 evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
1364 evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
1365 evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
1366 evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
1367 evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
1368 evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
1369 evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
1371 evTag->SetTotalMomentum(totalP);
1372 evTag->SetMeanPt(meanPt);
1373 evTag->SetMaxPt(maxPt);
1374 tag->AddEventTag(*evTag);
1376 if(fLastEvent == -1) lastEvent = (Int_t)aodTree->GetEntries();
1377 else lastEvent = fLastEvent;
1383 sprintf(fileName, "Run%d.Event%d_%d.AOD.tag.root",
1384 tag->GetRunId(),fFirstEvent,lastEvent );
1385 AliInfo(Form("writing tags to file %s", fileName));
1386 AliDebug(1, Form("writing tags to file %s", fileName));
1388 TFile* ftag = TFile::Open(fileName, "recreate");