Line data Source code
1 : /**************************************************************************
2 : * Author: Panos Christakoglou. *
3 : * Contributors are mentioned in the code where appropriate. *
4 : * *
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 : **************************************************************************/
13 :
14 : /* $Id$ */
15 :
16 : //-----------------------------------------------------------------
17 : // AliAODTagCreator 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 : //-----------------------------------------------------------------
21 :
22 : //ROOT
23 : #include <Riostream.h>
24 : #include <TFile.h>
25 : #include <TString.h>
26 : #include <TTree.h>
27 : #include <TSystem.h>
28 : #include <TChain.h>
29 : #include <TLorentzVector.h>
30 : #include <TRefArray.h>
31 :
32 : //ROOT-AliEn
33 : #include <TGrid.h>
34 : #include <TGridResult.h>
35 :
36 : //AliRoot
37 : #include "AliRunTag.h"
38 : #include "AliEventTag.h"
39 : #include "AliFileTag.h"
40 : #include "AliPID.h"
41 : #include "AliAODEvent.h"
42 : #include "AliAODVertex.h"
43 : #include "AliLog.h"
44 :
45 : #include "AliAODTagCreator.h"
46 :
47 : using std::ifstream;
48 170 : ClassImp(AliAODTagCreator)
49 :
50 :
51 : //______________________________________________________________________________
52 : AliAODTagCreator::AliAODTagCreator() :
53 2 : AliTagCreator(),
54 2 : fChain(0),
55 2 : fAODEvent(0),
56 2 : fTreeT(0),
57 2 : fRunTag(0),
58 2 : fTreeTEsd(0),
59 2 : fRunTagEsd(0)
60 10 : {
61 : //==============Default constructor for a AliAODTagCreator================
62 4 : }
63 :
64 : //______________________________________________________________________________
65 0 : AliAODTagCreator::~AliAODTagCreator() {
66 : //================Default destructor for a AliAODTagCreator===================
67 0 : delete fChain;
68 0 : delete fAODEvent;
69 0 : }
70 :
71 : //______________________________________________________________________________
72 : Bool_t AliAODTagCreator::ReadGridCollection(TGridResult *fresult) {
73 : // Reads the entry of the TGridResult and creates the tags
74 0 : Int_t nEntries = fresult->GetEntries();
75 :
76 0 : TString alienUrl;
77 : const char* guid;
78 : const char* md5;
79 : // const char* turl;
80 : Long64_t size = -1;
81 :
82 0 : fChain = new TChain("aodTree");
83 :
84 0 : for(Int_t i = 0; i < nEntries; i++) {
85 0 : alienUrl = fresult->GetKey(i,"turl");
86 0 : guid = fresult->GetKey(i,"guid");
87 0 : if(fresult->GetKey(i,"size")) size = atol (fresult->GetKey(i,"size"));
88 0 : md5 = fresult->GetKey(i,"md5");
89 : // turl = fresult->GetKey(i,"turl");
90 0 : if(md5 && !strlen(guid)) md5 = 0;
91 0 : if(guid && !strlen(guid)) guid = 0;
92 :
93 0 : fChain->Add(alienUrl);
94 : }//grid result loop
95 :
96 0 : AliInfo(Form("AOD chain created......."));
97 0 : AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));
98 :
99 0 : CreateTag(fChain, "grid");
100 :
101 : return kTRUE;
102 0 : }
103 :
104 : //______________________________________________________________________________
105 : Bool_t AliAODTagCreator::ReadLocalCollection(const char *localpath, const char* pattern) {
106 : // Checks the different subdirs of the given local path and in the
107 : // case where it finds an AliAOD.root file it creates the tags
108 :
109 0 : void *dira = gSystem->OpenDirectory(localpath);
110 0 : Char_t fPath[512];
111 : const char * dirname = 0x0;
112 : const char * filename = 0x0;
113 :
114 0 : fChain = new TChain("aodTree");
115 :
116 0 : while((dirname = gSystem->GetDirEntry(dira))) {
117 0 : snprintf(fPath,512,"%s/%s",localpath,dirname);
118 0 : void *dirb = gSystem->OpenDirectory(fPath);
119 0 : while((filename = gSystem->GetDirEntry(dirb))) {
120 0 : TString bstr = dirname;
121 0 : if(bstr.Contains("..")) continue;
122 0 : if(strstr(filename,pattern)) {
123 0 : TString aodFileName;
124 0 : aodFileName = fPath;
125 0 : aodFileName += "/";
126 0 : aodFileName += pattern;
127 0 : fChain->Add(aodFileName);
128 0 : } //pattern check
129 0 : } //child directory's entry loop
130 : } //parent directory's entry loop
131 :
132 0 : AliInfo(Form("AOD chain created......."));
133 0 : AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));
134 :
135 0 : CreateTag(fChain, "local");
136 :
137 0 : return kTRUE;
138 0 : }
139 :
140 : //______________________________________________________________________________
141 : Bool_t AliAODTagCreator::ReadCAFCollection(const char *filename) {
142 : // Temporary solution for CAF: Takes as an input the ascii file that
143 : // lists the AODs stored in the SE of the CAF and creates the tags.
144 :
145 : // Open the input stream
146 0 : ifstream in;
147 0 : in.open(filename);
148 :
149 0 : TString aodfile;
150 :
151 0 : fChain = new TChain("aodTree");
152 :
153 : // Read the input list of files and add them to the chain
154 0 : while(in.good()) {
155 0 : in >> aodfile;
156 0 : if (!aodfile.Contains("root")) continue; // protection
157 0 : fChain->Add(aodfile);
158 : }
159 :
160 0 : AliInfo(Form("AOD chain created......."));
161 0 : AliInfo(Form("Chain entries: %lld",fChain->GetEntries()));
162 :
163 0 : CreateTag(fChain, "proof");
164 :
165 : return kTRUE;
166 0 : }
167 :
168 : //__________________________________________________________________________
169 : void AliAODTagCreator::CreateAODTags(Int_t fFirstEvent, Int_t fLastEvent, TList */*grpList*/) {
170 : // Creates tag files for AODs
171 :
172 0 : AliInfo(Form("Creating the AOD tags......."));
173 :
174 0 : TFile *file = TFile::Open("AliAOD.root");
175 0 : if (!file || !file->IsOpen()) {
176 0 : AliError(Form("opening failed"));
177 0 : delete file;
178 0 : return ;
179 : }
180 :
181 0 : fChain = new TChain("aodTree");
182 0 : fChain->Add("AliAOD.root");
183 :
184 0 : fAODEvent = new AliAODEvent();
185 0 : fAODEvent->ReadFromTree(fChain);
186 :
187 : Int_t lastEvent = 0;
188 0 : if(fLastEvent == -1) lastEvent = (Int_t)fChain->GetEntries();
189 : else lastEvent = fLastEvent;
190 :
191 0 : char fileName[256];
192 0 : snprintf(fileName, 256, "Run%d.Event%d_%d.AOD.tag.root",
193 0 : fAODEvent->GetRunNumber(), fFirstEvent, lastEvent );
194 0 : AliInfo(Form("writing tags to file %s", fileName));
195 0 : AliDebug(1, Form("writing tags to file %s", fileName));
196 :
197 0 : TFile* ftag = TFile::Open(fileName, "recreate");
198 :
199 0 : fRunTag = new AliRunTag();
200 0 : fTreeT = new TTree("T","A Tree with event tags");
201 0 : TBranch * btag = fTreeT->Branch("AliTAG", &fRunTag);
202 0 : btag->SetCompressionLevel(9);
203 :
204 0 : CreateTags();
205 :
206 0 : ftag->cd();
207 0 : fTreeT->Fill();
208 0 : fRunTag->Clear();
209 0 : fTreeT->Write();
210 0 : ftag->Close();
211 0 : file->cd();
212 0 : file->Close();
213 0 : }
214 :
215 : //_____________________________________________________________________________
216 : void AliAODTagCreator::CreateTag(TChain* chain, const char *type) {
217 :
218 : // Private method that creates tag files
219 : //
220 :
221 : //reading the esd tag file
222 0 : fTreeTEsd = new TChain("T");
223 : const char * tagPattern = "ESD.tag";
224 : // Open the working directory
225 0 : void * dirp = gSystem->OpenDirectory(gSystem->pwd());
226 : const char * name = 0x0;
227 : // Add all files matching *pattern* to the chain
228 0 : while((name = gSystem->GetDirEntry(dirp))) {
229 0 : if (strstr(name,tagPattern)) fTreeTEsd->Add(name);
230 : }//directory loop
231 0 : AliInfo(Form("Chained tag files: %lld",fTreeTEsd->GetEntries()));
232 :
233 0 : fChain = chain;
234 :
235 0 : TString fSession = type;
236 0 : TString fguid, fmd5, fturl;
237 0 : fAODEvent = new AliAODEvent();
238 0 : fAODEvent->ReadFromTree(fChain);
239 :
240 : Int_t firstEvent = 0;
241 :
242 0 : TString localFileName = "Run";
243 0 : localFileName += fAODEvent->GetRunNumber();
244 0 : localFileName += ".Event";
245 0 : localFileName += firstEvent;
246 0 : localFileName += "_";
247 0 : localFileName += chain->GetEntries(); //localFileName += "."; localFileName += Counter;
248 0 : localFileName += ".AOD.tag.root";
249 :
250 0 : TString fileName;
251 :
252 0 : if(fStorage == 0) {
253 0 : fileName = localFileName.Data();
254 0 : AliInfo(Form("Writing tags to local file: %s",fileName.Data()));
255 : }
256 0 : else if(fStorage == 1) {
257 0 : TString alienLocation = "/alien";
258 0 : alienLocation += gGrid->Pwd();
259 0 : alienLocation += fgridpath.Data();
260 0 : alienLocation += "/";
261 0 : alienLocation += localFileName;
262 0 : alienLocation += "?se=";
263 0 : alienLocation += fSE.Data();
264 0 : fileName = alienLocation.Data();
265 0 : AliInfo(Form("Writing tags to grid file: %s",fileName.Data()));
266 0 : }
267 :
268 0 : TFile* ftag = TFile::Open(fileName, "recreate");
269 :
270 0 : fRunTag = new AliRunTag();
271 0 : fTreeT = new TTree("T", "A Tree with event tags");
272 0 : TBranch * btag = fTreeT->Branch("AliTAG", &fRunTag);
273 0 : btag->SetCompressionLevel(9);
274 :
275 : // Access information from esd tag
276 0 : fRunTagEsd = new AliRunTag();
277 0 : fTreeTEsd->SetBranchAddress("AliTAG",&fRunTagEsd);
278 : // Creating new information of aod
279 0 : AliInfo(Form("Creating the AOD tags......."));
280 0 : CreateTags(type);
281 0 : ftag->cd();
282 0 : fRunTag->Clear();
283 0 : fTreeT->Write();
284 0 : ftag->Close();
285 0 : }
286 :
287 : void AliAODTagCreator::CreateTags(const char* /*type*/)
288 : {
289 : // Event loop for tag creation
290 0 : TString fturl;
291 0 : TString fguid;
292 : Int_t oldRun = -1;
293 0 : fChain->GetEntry(0);
294 0 : TFile *f = fChain->GetFile();
295 0 : TString ftempGuid = f->GetUUID().AsString();
296 : // Loop over events
297 0 : Int_t nEvents = fChain->GetEntries();
298 : Int_t ntags = 0;
299 : Int_t tagentry = 0;
300 : // const TClonesArray *evTagList = 0;
301 0 : TString foldguid = "";
302 :
303 0 : for (Int_t iEventNumber = 0; iEventNumber < nEvents; iEventNumber++) {
304 : // Copy old tag information
305 0 : if (iEventNumber >= ntags) {
306 0 : fTreeTEsd->GetEntry(tagentry++);
307 0 : fRunTag->CopyStandardContent(fRunTagEsd);
308 : // evTagList = fRunTagEsd->GetEventTags();
309 : // ntags += evTagList->GetEntries();
310 0 : ntags = fRunTagEsd->GetNEvents();
311 0 : }
312 :
313 : // Create a new Tag
314 0 : AliEventTag* evTag = new AliEventTag();
315 : // Read event
316 0 : fChain->GetEntry(iEventNumber);
317 0 : if (iEventNumber == 0) oldRun = fAODEvent->GetRunNumber();
318 : // Reference to the input file
319 0 : TFile *file = fChain->GetFile();
320 : // const TUrl *url = file->GetEndpointUrl();
321 0 : fguid = file->GetUUID().AsString();
322 :
323 : // if (!strcmp(type,"grid")) {
324 : // TString fturltemp = "alien://"; fturltemp += url->GetFile();
325 : // fturl = fturltemp(0,fturltemp.Index(".root",5,0,TString::kExact)+5);
326 : // } else {
327 : // fturl = url->GetFile();
328 : // }
329 0 : fturl = file->GetName();
330 :
331 0 : fAODEvent->GetStdContent();
332 :
333 : // Fill the event tag from the aod informatiom
334 0 : FillEventTag(fAODEvent, evTag);
335 : // Set the event and input file references
336 : //evTag->SetEventId(iEventNumber+1);
337 :
338 : // **** FIXME ****
339 : // evTag->SetGUID(fguid);
340 : // if(!strcmp(type,"grid")) {
341 : // evTag->SetMD5("");
342 : // evTag->SetTURL(fturl);
343 : // evTag->SetSize(0);
344 : // }
345 : // else evTag->SetPath(fturl);
346 : // **** FIXME ****
347 :
348 : // Check if a new run has to be created
349 : // File has changed
350 0 : if(fguid != ftempGuid) {
351 0 : ftempGuid = fguid;
352 0 : fTreeT->Fill();
353 0 : fRunTag->Clear("");
354 :
355 0 : AliFileTag *nftag = new AliFileTag();
356 :
357 : // if(fSession == "grid") {
358 0 : nftag->SetMD5("");
359 0 : nftag->SetTURL(fturl);
360 0 : nftag->SetSize(0);
361 : // }
362 : // else {
363 : // nftag->SetPath(fturl);
364 : // nftag->SetSize(0);
365 : // nftag->SetMD5("");
366 : // nftag->SetTURL(fturl);
367 : // }
368 :
369 0 : if (fRunTag->GetFileId(fguid) > -1)
370 0 : AliFatal("Adding a file which is already in the RunTag.");
371 :
372 0 : fRunTag->AddFileTag(nftag);
373 :
374 0 : }
375 :
376 : // Run# has changed
377 0 : if (oldRun != (fAODEvent->GetRunNumber()))
378 : {
379 0 : oldRun = fAODEvent->GetRunNumber();
380 :
381 0 : fTreeT->Fill();
382 0 : fRunTag->Clear("");
383 0 : ftempGuid = fguid;
384 0 : fTreeT->Fill();
385 0 : fRunTag->Clear("");
386 :
387 0 : AliFileTag *nftag = new AliFileTag();
388 :
389 : // if(fSession == "grid") {
390 0 : nftag->SetMD5("");
391 0 : nftag->SetTURL(fturl);
392 0 : nftag->SetSize(0);
393 : // }
394 : // else {
395 : // nftag->SetPath(fturl);
396 : // nftag->SetSize(0);
397 : // nftag->SetMD5("");
398 : // nftag->SetTURL(fturl);
399 : // }
400 :
401 0 : if (fRunTag->GetFileId(fguid) > -1)
402 0 : AliFatal("Adding a file which is already in the RunTag.");
403 :
404 0 : fRunTag->AddFileTag(nftag);
405 :
406 0 : }
407 :
408 : // Add the event tag
409 0 : fRunTag->AddEventTag(*evTag);
410 0 : delete evTag;
411 : // Last event
412 0 : if(iEventNumber+1 == fChain->GetEntries()) {
413 0 : fTreeT->Fill();
414 0 : fRunTag->Clear("");
415 : }
416 : }//event loop
417 0 : }
418 :
419 :
420 :
421 : void AliAODTagCreator::FillEventTag(AliAODEvent* aod, AliEventTag* evTag)
422 : {
423 : //
424 : // Fill the event tag information
425 : //
426 16 : fAODEvent = aod;
427 :
428 : //
429 : Float_t fLowPtCut = 1.0;
430 : Float_t fHighPtCut = 3.0;
431 : Float_t fVeryHighPtCut = 10.0;
432 : ////////////
433 8 : Double_t partFrac[10] = {0.01, 0.01, 0.85, 0.10, 0.05, 0., 0., 0., 0., 0.};
434 :
435 : // Creates the tags for all the events in a given AOD file
436 : Int_t ntrack = 0;
437 : Int_t nPos = 0, nNeg = 0, nNeutr =0;
438 : Int_t nKinks = 0, nV0s = 0, nCascades = 0;
439 : Int_t nK0s = 0, nNeutrons = 0, nPi0s = 0, nGamas = 0;
440 : Int_t nProtons = 0, nKaons = 0, nPions = 0, nMuons = 0, nElectrons = 0, nFWMuons = 0;
441 : Int_t nCh1GeV = 0, nCh3GeV = 0, nCh10GeV = 0;
442 : Int_t nMu1GeV = 0, nMu3GeV = 0, nMu10GeV = 0;
443 : Int_t nEl1GeV = 0, nEl3GeV = 0, nEl10GeV = 0;
444 : Float_t maxPt = .0, etamaxPt = -999., phimaxPt = -999., meanPt = .0, totalP = .0;
445 :
446 8 : TRefArray tmp;
447 :
448 :
449 : // Primary Vertex
450 8 : AliAODVertex *pVertex = fAODEvent->GetPrimaryVertex();
451 8 : if (pVertex) {
452 16 : evTag->SetVertexX(pVertex->GetX());
453 16 : evTag->SetVertexY(pVertex->GetY());
454 16 : evTag->SetVertexZ(pVertex->GetZ());
455 8 : Double_t covmatrix[6];
456 8 : pVertex->GetCovarianceMatrix(covmatrix);
457 8 : evTag->SetVertexZError(sqrt(covmatrix[5]));
458 8 : }
459 : // loop over vertices
460 8 : Int_t nVtxs = fAODEvent->GetNumberOfVertices();
461 104 : for (Int_t nVtx = 0; nVtx < nVtxs; nVtx++) {
462 44 : AliAODVertex *vertex = fAODEvent->GetVertex(nVtx);
463 48 : if(vertex->GetType() == 1) nKinks += 1;
464 60 : if(vertex->GetType() == 2) nV0s += 1;
465 44 : if(vertex->GetType() == 3) nCascades += 1;
466 : }
467 8 : Int_t nTracks = fAODEvent->GetNumberOfTracks();
468 290 : for (Int_t nTr = 0; nTr < nTracks; nTr++) {
469 548 : AliAODTrack *track = dynamic_cast<AliAODTrack*>(fAODEvent->GetTrack(nTr));
470 137 : if(!track) AliFatal("Not a standard AOD");
471 :
472 137 : Double_t fPt = track->Pt();
473 137 : if(fPt > maxPt) {
474 14 : maxPt = fPt;
475 28 : etamaxPt = track->Eta();
476 28 : phimaxPt = track->Phi();
477 14 : }
478 :
479 274 : if(track->Charge() > 0) {
480 69 : nPos++;
481 122 : if(fPt > fLowPtCut) nCh1GeV++;
482 89 : if(fPt > fHighPtCut) nCh3GeV++;
483 85 : if(fPt > fVeryHighPtCut) nCh10GeV++;
484 : }
485 274 : if(track->Charge() < 0) {
486 68 : nNeg++;
487 116 : if(fPt > fLowPtCut) nCh1GeV++;
488 80 : if(fPt > fHighPtCut) nCh3GeV++;
489 76 : if(fPt > fVeryHighPtCut) nCh10GeV++;
490 : }
491 274 : if(track->Charge() == 0) nNeutr++;
492 : //PID
493 137 : const Double32_t *prob = track->PID();
494 137 : if (prob) {
495 : Double_t rcc = 0.0;
496 0 : for(Int_t i = 0; i < AliPID::kSPECIES; i++) rcc += prob[i]*partFrac[i];
497 0 : if(rcc > 0.0) {
498 : //Bayes' formula
499 0 : Double_t w[10];
500 0 : for(Int_t i = 0; i < AliPID::kSPECIES; i++) w[i] = prob[i]*partFrac[i]/rcc;
501 :
502 : //protons
503 0 : if ((w[4]>w[3])&&(w[4]>w[2])&&(w[4]>w[1])&&(w[4]>w[0])) nProtons++;
504 : //kaons
505 0 : if ((w[3]>w[4])&&(w[3]>w[2])&&(w[3]>w[1])&&(w[3]>w[0])) nKaons++;
506 : //pions
507 0 : if ((w[2]>w[4])&&(w[2]>w[3])&&(w[2]>w[1])&&(w[2]>w[0])) nPions++;
508 : //muons
509 0 : if ((w[1]>w[4])&&(w[1]>w[3])&&(w[1]>w[2])&&(w[1]>w[0])) {
510 0 : nMuons++;
511 0 : if(fPt > fLowPtCut) nMu1GeV++;
512 0 : if(fPt > fHighPtCut) nMu3GeV++;
513 0 : if(fPt > fVeryHighPtCut) nMu10GeV++;
514 : }
515 : //electrons
516 0 : if ((w[0]>w[4])&&(w[0]>w[3])&&(w[0]>w[2])&&(w[0]>w[1])) {
517 0 : nElectrons++;
518 0 : if(fPt > fLowPtCut) nEl1GeV++;
519 0 : if(fPt > fHighPtCut) nEl3GeV++;
520 0 : if(fPt > fVeryHighPtCut) nEl10GeV++;
521 : }
522 0 : }
523 0 : }
524 274 : totalP += track->P();
525 137 : meanPt += fPt;
526 137 : ntrack++;
527 : // forward muons (in the dimuon spectrometer)
528 290 : if(track->IsMuonTrack()) nFWMuons++;
529 :
530 : }//track loop
531 : //
532 : // Fill the event tags
533 8 : if(ntrack != 0)
534 8 : meanPt = meanPt/ntrack;
535 :
536 :
537 8 : evTag->SetNumOfTracks(nTracks);
538 8 : evTag->SetNumOfPosTracks(nPos);
539 8 : evTag->SetNumOfNegTracks(nNeg);
540 8 : evTag->SetNumOfNeutrTracks(nNeutr);
541 :
542 8 : evTag->SetNumOfV0s(nV0s);
543 8 : evTag->SetNumOfCascades(nCascades);
544 8 : evTag->SetNumOfKinks(nKinks);
545 :
546 8 : evTag->SetNumOfProtons(nProtons);
547 8 : evTag->SetNumOfKaons(nKaons);
548 8 : evTag->SetNumOfPions(nPions);
549 8 : evTag->SetNumOfMuons(nMuons);
550 8 : evTag->SetNumOfFWMuons(nFWMuons);
551 8 : evTag->SetNumOfElectrons(nElectrons);
552 8 : evTag->SetNumOfPhotons(nGamas);
553 8 : evTag->SetNumOfPi0s(nPi0s);
554 8 : evTag->SetNumOfNeutrons(nNeutrons);
555 8 : evTag->SetNumOfKaon0s(nK0s);
556 :
557 8 : evTag->SetNumOfChargedAbove1GeV(nCh1GeV);
558 8 : evTag->SetNumOfChargedAbove3GeV(nCh3GeV);
559 8 : evTag->SetNumOfChargedAbove10GeV(nCh10GeV);
560 8 : evTag->SetNumOfMuonsAbove1GeV(nMu1GeV);
561 8 : evTag->SetNumOfMuonsAbove3GeV(nMu3GeV);
562 8 : evTag->SetNumOfMuonsAbove10GeV(nMu10GeV);
563 8 : evTag->SetNumOfElectronsAbove1GeV(nEl1GeV);
564 8 : evTag->SetNumOfElectronsAbove3GeV(nEl3GeV);
565 8 : evTag->SetNumOfElectronsAbove10GeV(nEl10GeV);
566 :
567 8 : tmp.Clear();
568 16 : evTag->SetNumOfPHOSClusters(fAODEvent->GetPHOSClusters(&tmp));
569 8 : tmp.Clear();
570 16 : evTag->SetNumOfEMCALClusters(fAODEvent->GetEMCALClusters(&tmp));
571 :
572 8 : evTag->SetTotalMomentum(totalP);
573 8 : evTag->SetMeanPt(meanPt);
574 8 : evTag->SetMaxPt(maxPt);
575 8 : evTag->SetEtaMaxPt(etamaxPt);
576 8 : evTag->SetPhiMaxPt(phimaxPt);
577 8 : }
|
