Fixes in order to treat correctly event and sub-event header extensions.
[u/mrichter/AliRoot.git] / MONITOR / AliMonitorProcess.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 //  This is the class for perfoming the monitoring process.                  //
21 //  It checks if a raw data file exists, loops over the events in the raw    //
22 //  data file, reconstructs TPC and ITS clusters and tracks, fills the       //
23 //  monitor histograms and sends the updated histograms to the clients.      //
24 //  Then the raw data file is deleted and it waits for a new file.           //
25 //                                                                           //
26 ///////////////////////////////////////////////////////////////////////////////
27
28 #include <TFile.h>
29 #include <TGrid.h>
30 #include <TGridResult.h>
31 #include <TMessage.h>
32 #include <TROOT.h>
33 #include <TServerSocket.h>
34 #include <TSocket.h>
35
36 #include "AliLog.h"
37 #include "AliESDEvent.h"
38 #include "AliITSclustererV2.h"
39 #include "AliITSgeom.h"
40 #include "AliITStrackerV2.h"
41 #include "AliLoader.h"
42 // Matthias 2007-10-03 HLT legacy code disabled
43 // everything encapsulated by ENABLE_ALIMONITORPROCESS_HLT
44 // set the define in the header file to include the code
45 #ifdef ENABLE_ALIMONITORPROCESS_HLT
46 #include "AliMonitorHLT.h"
47 #include "AliMonitorHLTHough.h"
48 #endif // ENABLE_ALIMONITORPROCESS_HLT
49 #include "AliMonitorITS.h"
50 #include "AliMonitorProcess.h"
51 #include "AliMonitorTPC.h"
52 #include "AliMonitorV0s.h"
53 #include "AliRawReaderRoot.h"
54 #include "AliRun.h"
55 #include "AliTPC.h"
56 #include "AliTPCclustererMI.h"
57 #include "AliTPCtrackerMI.h"
58 #include "AliV0vertexer.h"
59
60 #ifdef ENABLE_ALIMONITORPROCESS_HLT
61 #include <AliHLTStandardIncludes.h>
62 #include <AliHLTMemHandler.h>
63 #include <AliHLTClusterFitter.h>
64 #include <AliHLTFitter.h>
65 #include <AliHLTHough.h>
66 #include <AliHLTHoughBaseTransformer.h>
67 #include <AliHLTStandardIncludes.h>
68 #include <AliHLTTrack.h>
69 #include <AliHLTTrackArray.h>
70 #include <AliHLTTransform.h>
71 #include <AliHLTVertex.h>
72 #include <AliLevel3.h>
73 #endif // ENABLE_ALIMONITORPROCESS_HLT
74
75 ClassImp(AliMonitorProcess)
76
77
78 const Int_t AliMonitorProcess::fgkPort = 9327;
79
80
81 //_____________________________________________________________________________
82 AliMonitorProcess::AliMonitorProcess(
83 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
84                                      const char* /*alienHost*/,
85 #else
86                                      const char* alienHost,
87 #endif
88                                      const char* alienDir,
89                                      const char* selection,
90                                      const char* fileNameGalice):
91   fSelection(selection),
92   fGrid(NULL),
93   fAlienDir(alienDir),
94   fRunLoader(NULL),
95   fTPCParam(NULL),
96   fITSgeom(NULL),
97   fLogicalFileName(""),
98   fFileName(""),
99   fHLT(NULL),
100   fHLTHough(NULL),
101
102   fRunNumber(0),
103   fSubRunNumber(0),
104   fNEvents(0),
105   fNEventsMin(1),
106   fWriteHistoList(kFALSE),
107
108   fTopFolder(NULL),
109   fMonitors(),
110   fFile(NULL),
111   fTree(NULL),
112
113   fServerSocket(NULL),
114   fSockets(),
115   fDisplaySocket(NULL),
116
117   fStatus(kStopped),
118   fStopping(kFALSE),
119
120   fInterruptHandler(NULL)
121 {
122 // initialize the monitoring process and the monitor histograms
123
124   fSelection = selection;
125
126 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
127   fGrid = TGrid::Connect("alien", gSystem->Getenv("USER"));
128 #else
129   fGrid = TGrid::Connect(alienHost, gSystem->Getenv("USER"));
130 #endif
131   if (!fGrid || fGrid->IsZombie() || !fGrid->IsConnected()) {
132     delete fGrid;
133     AliFatal("could not connect to alien");
134   }
135 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
136   fGrid->cd(alienDir);
137 #endif
138
139   fRunLoader = AliRunLoader::Open(fileNameGalice);
140   if (!fRunLoader) AliFatal(Form("could not get run loader from file %s",
141                                  fileNameGalice));
142
143   fRunLoader->CdGAFile();
144   fTPCParam = AliTPC::LoadTPCParam(gFile);
145   if (!fTPCParam) AliFatal("could not load TPC parameters");
146
147   fRunLoader->LoadgAlice();
148   gAlice = fRunLoader->GetAliRun();
149   if (!gAlice) AliFatal("no gAlice object found");
150   fITSgeom = (AliITSgeom*)gDirectory->Get("AliITSgeom");
151   if (!fITSgeom) AliFatal("could not load ITS geometry");
152
153 #ifdef ENABLE_ALIMONITORPROCESS_HLT
154   // Init TPC parameters for HLT
155   Bool_t isinit=AliHLTTransform::Init(const_cast<char*>(fileNameGalice),kTRUE);
156   if(!isinit){
157     AliFatal("Could not create transform settings, please check log for error messages!");
158   }
159 #endif // ENABLE_ALIMONITORPROCESS_HLT
160
161   fTopFolder = new TFolder("Monitor", "monitor histograms");
162   fTopFolder->SetOwner(kTRUE);
163
164   if (IsSelected("TPC")) fMonitors.Add(new AliMonitorTPC(fTPCParam));
165   if (IsSelected("ITS")) fMonitors.Add(new AliMonitorITS(fITSgeom));
166   if (IsSelected("V0s")) fMonitors.Add(new AliMonitorV0s);
167 #ifdef ENABLE_ALIMONITORPROCESS_HLT
168   if (IsSelected("HLTConfMap")) fMonitors.Add(new AliMonitorHLT(fTPCParam));
169   if (IsSelected("HLTHough")) fMonitors.Add(new AliMonitorHLTHough(fTPCParam));
170 #endif // ENABLE_ALIMONITORPROCESS_HLT
171
172   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
173     ((AliMonitor*) fMonitors[iMonitor])->CreateHistos(fTopFolder);
174   }
175
176   TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
177   while (TFolder* folder = (TFolder*) iFolder->Next()) folder->SetOwner(kTRUE);
178   delete iFolder;
179
180   fFile = TFile::Open("monitor_tree.root", "RECREATE");
181   if (!fFile || !fFile->IsOpen()) {
182     AliFatal("could not open file for tree");
183   }
184   fTree = new TTree("MonitorTree", "tree for monitoring");
185   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
186     ((AliMonitor*) fMonitors[iMonitor])->CreateBranches(fTree);
187   }
188   gROOT->cd();
189
190   fServerSocket = new TServerSocket(fgkPort, kTRUE);
191   fServerSocket->SetOption(kNoBlock, 1);
192   CheckForConnections();
193
194   fInterruptHandler = new AliMonitorInterruptHandler(this);
195   gSystem->AddSignalHandler(fInterruptHandler);
196 }
197
198 //_____________________________________________________________________________
199 AliMonitorProcess::AliMonitorProcess(const AliMonitorProcess& process) :
200   TObject(process),
201
202   fSelection(""),
203   fGrid(NULL),
204   fAlienDir(""),
205   fRunLoader(NULL),
206   fTPCParam(NULL),
207   fITSgeom(NULL),
208   fLogicalFileName(""),
209   fFileName(""),
210   fHLT(NULL),
211   fHLTHough(NULL),
212
213   fRunNumber(0),
214   fSubRunNumber(0),
215   fNEvents(0),
216   fNEventsMin(1),
217   fWriteHistoList(kFALSE),
218
219   fTopFolder(NULL),
220   fMonitors(),
221   fFile(NULL),
222   fTree(NULL),
223
224   fServerSocket(NULL),
225   fSockets(),
226   fDisplaySocket(NULL),
227
228   fStatus(kStopped),
229   fStopping(kFALSE),
230
231   fInterruptHandler(NULL)
232
233 {
234   AliFatal("copy constructor not implemented");
235 }
236
237 //_____________________________________________________________________________
238 AliMonitorProcess& AliMonitorProcess::operator = (const AliMonitorProcess&
239                                                   /*process*/)
240 {
241   AliFatal("assignment operator not implemented");
242   return *this;
243 }
244
245 //_____________________________________________________________________________
246 AliMonitorProcess::~AliMonitorProcess()
247 {
248 // clean up
249
250   fMonitors.Delete();
251   delete fTopFolder;
252   delete fRunLoader;
253
254   delete fServerSocket;
255   fSockets.Delete();
256   delete fDisplaySocket;
257
258 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
259   fGrid->Close();
260 #endif
261   delete fGrid;
262
263   fFile->Close();
264   delete fFile;
265   gSystem->Unlink("monitor_tree.root");
266
267 #ifdef ENABLE_ALIMONITORPROCESS_HLT
268   delete fHLT;
269   delete fHLTHough;
270 #endif // ENABLE_ALIMONITORPROCESS_HLT
271
272   gSystem->RemoveSignalHandler(fInterruptHandler);
273   delete fInterruptHandler;
274 }
275
276
277 //_____________________________________________________________________________
278 const char* AliMonitorProcess::GetRevision()
279 {
280   return "$Revision$";
281 }
282
283
284 //_____________________________________________________________________________
285 void AliMonitorProcess::SetStatus(EStatus status)
286 {
287 // set the current status and process system events
288
289   fStatus = status;
290   gSystem->ProcessEvents();
291 }
292
293
294 //_____________________________________________________________________________
295 void AliMonitorProcess::Run()
296 {
297 // run the monitor process:
298 //  check for a raw data file, process the raw data file and delete it
299
300   fStopping = kFALSE;
301
302   while (!fStopping) {
303     SetStatus(kWaiting);
304     while (!CheckForNewFile()) {
305       CheckForConnections();
306       SetStatus(kWaiting);
307       if (fStopping) break;
308       gSystem->Sleep(10);
309     }
310     if (fStopping) break;
311
312     ProcessFile();
313   }
314
315   WriteHistos();
316
317   fStopping = kFALSE;
318   SetStatus(kStopped);
319 }
320
321
322 //_____________________________________________________________________________
323 void AliMonitorProcess::Stop()
324 {
325 // set the fStopping flag to terminate the monitor process after the current
326 // event was processed
327
328   if (GetStatus() != kStopped) fStopping = kTRUE;
329 }
330
331
332 //_____________________________________________________________________________
333 void AliMonitorProcess::ProcessFile(const char* fileName)
334 {
335 // create a file with monitor histograms for a single file
336
337   if (GetStatus() != kStopped) {
338     AliError("ProcessFile can not be called"
339              " while the monitor process is running");
340     return;
341   }
342
343   fFileName = fileName;
344   Int_t nEventMin = fNEventsMin;
345   fNEventsMin = 1;
346   ProcessFile();
347   WriteHistos();
348   fNEventsMin = nEventMin;
349   SetStatus(kStopped);
350 }
351
352
353 //_____________________________________________________________________________
354 Bool_t AliMonitorProcess::CheckForNewFile()
355 {
356 // check whether a new file was registered in alien
357
358 #if ROOT_VERSION_CODE < ROOT_VERSION(5,0,0)
359 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
360   TGridResult* result = fGrid->Ls();
361 #else
362   TDatime datime;
363   char dirName[256];
364   sprintf(dirName, "%s/adc-%d", fAlienDir.Data(), datime.GetDate());
365   char findName[256];
366   sprintf(findName, "*.root");
367   Grid_ResultHandle_t handle = fGrid->Find(dirName, findName);
368   if (!handle) {
369     AliError(Form("could not open alien directory %s",
370                   dirName));
371     return kFALSE;
372   }
373   TGridResult* result = fGrid->CreateGridResult(handle);
374 #endif
375   Long_t maxDate = -1;
376   Long_t maxTime = -1;
377   TString fileName;
378
379 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
380   while (const char* entry = result->Next()) {
381 #else
382   while (Grid_Result_t* resultEntry = result->Next()) {
383     const char* entry = resultEntry->name.c_str();
384 #endif
385     if (strrchr(entry, '/')) entry = strrchr(entry, '/')+1;
386     // entry = host_date_time.root
387     TString entryCopy(entry);
388     char* p = const_cast<char*>(entryCopy.Data());
389     if (!strtok(p, "_") || !p) continue;  // host name
390     char* dateStr = strtok(NULL, "_");
391     if (!dateStr || !p) continue;
392     char* timeStr = strtok(NULL, ".");
393     if (!timeStr || !p) continue;
394     Long_t date = atoi(dateStr);
395     Long_t time = atoi(timeStr);
396
397     if ((date > maxDate) || ((date == maxDate) && (time > maxTime))) {
398       maxDate = date;
399       maxTime = time;
400       fileName = entry;
401     }
402   }
403
404   delete result;
405   if (maxDate < 0) return kFALSE;  // no files found
406   if (fLogicalFileName.CompareTo(fileName) == 0) return kFALSE;  // no new file
407
408   fLogicalFileName = fileName;
409 #if ROOT_VERSION_CODE <= 199169   // 3.10/01
410   result = fGrid->GetPhysicalFileNames(fLogicalFileName.Data());
411   fFileName = result->Next();
412 #else
413   fileName = dirName + ("/" + fLogicalFileName);
414   handle = fGrid->GetPhysicalFileNames(fileName.Data());
415   if (!handle) {
416     AliError(Form("could not get physical file names for %s",
417                   fileName.Data()));
418     return kFALSE;
419   }
420   result = fGrid->CreateGridResult(handle);
421   result->Reset();
422   Grid_Result_t* resultEntry = result->Next();
423   if (!resultEntry) {
424     AliError(Form("could not get physical file names for %s",
425                   fileName.Data()));
426     return kFALSE;
427   }
428   fFileName = resultEntry->name2.c_str();
429   fFileName.ReplaceAll("castor:/", "rfio:/");
430 #endif
431   delete result;
432 #else
433   Error("CheckForNewFile", "needs to be ported to new TGrid");
434 #endif
435   return kTRUE;
436 }
437
438 //_____________________________________________________________________________
439 Bool_t AliMonitorProcess::ProcessFile()
440 {
441 // loop over all events in the raw data file, run the reconstruction
442 // and fill the monitor histograms
443
444   Int_t nEvents = GetNumberOfEvents(fFileName);
445   if (nEvents <= 0) return kFALSE;
446   AliDebug(1, Form("found %d event(s) in file %s",
447                    nEvents, fFileName.Data()));
448 #ifdef ENABLE_ALIMONITORPROCESS_HLT
449   if (IsSelected("HLTConfMap")) CreateHLT(fFileName);
450   if (IsSelected("HLTHough")) CreateHLTHough(fFileName);
451 #endif // ENABLE_ALIMONITORPROCESS_HLT
452
453   // loop over the events
454   for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
455     CheckForConnections();
456     SetStatus(kReading);
457     fRunLoader->SetEventNumber(0);
458     AliRawReaderRoot rawReader(fFileName, iEvent);
459     if (fStopping) break;
460     if (rawReader.GetRunNumber() != fRunNumber) {
461       WriteHistos();
462       StartNewRun();
463       fRunNumber = rawReader.GetRunNumber();
464       fEventNumber[0] = rawReader.GetEventId()[0];
465       fEventNumber[1] = rawReader.GetEventId()[1];
466       fSubRunNumber = 0;
467       if (fStopping) break;
468     }
469
470     // monitor only central physics events
471     if (rawReader.GetType() != 7) continue;
472     if ((rawReader.GetAttributes()[0] & 0x02) == 0) continue;
473     AliInfo(Form("run: %d  event: %d %d\n", rawReader.GetRunNumber(),
474                  rawReader.GetEventId()[0], rawReader.GetEventId()[1]));
475
476     AliESDEvent esd;
477     if (IsSelected("TPC")) {
478       CheckForConnections();
479       if (!ReconstructTPC(&rawReader, &esd)) return kFALSE;
480       if (fStopping) break;
481     }
482     if (IsSelected("ITS")) {
483       CheckForConnections();
484       if (!ReconstructITS(&rawReader, &esd)) return kFALSE;
485       if (fStopping) break;
486     }
487     if (IsSelected("V0s")) {
488       CheckForConnections();
489       if (!ReconstructV0s(&esd)) return kFALSE;
490       if (fStopping) break;
491     }
492 #ifdef ENABLE_ALIMONITORPROCESS_HLT
493     if (IsSelected("HLTConfMap")) {
494       CheckForConnections();
495       if (!ReconstructHLT(iEvent)) return kFALSE;
496       if (fStopping) break;
497     }
498     if (IsSelected("HLTHough")) {
499       CheckForConnections();
500       if (!ReconstructHLTHough(iEvent)) return kFALSE;
501       if (fStopping) break;
502     }
503 #endif // ENABLE_ALIMONITORPROCESS_HLT
504
505     if (fDisplaySocket) fDisplaySocket->Send("new event");
506
507     AliDebug(1, "filling histograms...");
508     for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
509       CheckForConnections();
510       SetStatus(kFilling);
511       ((AliMonitor*) fMonitors[iMonitor])->FillHistos(fRunLoader, &rawReader,
512                                                       &esd);
513       if (fStopping) break;
514     }
515     if (fStopping) break;
516
517     AliDebug(1, "updating histograms...");
518     CheckForConnections();
519     SetStatus(kUpdating);
520     TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
521     while (TFolder* folder = (TFolder*) iFolder->Next()) {
522       TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
523       while (AliMonitorPlot* histo = (AliMonitorPlot*) iHisto->Next()) {
524         histo->Update();
525       }
526       delete iHisto;
527     }
528     delete iFolder;
529     if (fStopping) break;
530
531     AliDebug(1, "filling the tree...");
532     fTree->Fill();
533
534     AliDebug(1, "broadcasting histograms...");
535     CheckForConnections();
536     BroadcastHistos();
537
538     fNEvents++;
539     if (fStopping) break;
540   }
541
542 #ifdef ENABLE_ALIMONITORPROCESS_HLT
543   if (fHLT) {
544     delete fHLT;
545     fHLT = NULL;
546   }
547   if (fHLTHough) {
548     delete fHLTHough;
549     fHLTHough = NULL;
550   }
551 #endif // ENABLE_ALIMONITORPROCESS_HLT
552
553   return kTRUE;
554 }
555
556 //_____________________________________________________________________________
557 void AliMonitorProcess::Reset()
558 {
559 // write the current histograms to a file and reset them
560
561   if (fSubRunNumber == 0) fSubRunNumber++;
562   WriteHistos();
563   StartNewRun();
564   fSubRunNumber++;
565 }
566
567
568 //_____________________________________________________________________________
569 UInt_t AliMonitorProcess::GetEventPeriodNumber() const
570 {
571 // get the period number from the event id
572
573   return (fEventNumber[1] >> 4);
574 }
575
576 //_____________________________________________________________________________
577 UInt_t AliMonitorProcess::GetEventOrbitNumber() const
578 {
579 // get the orbit number from the event id
580
581   return ((fEventNumber[1] & 0x000F) << 20) + (fEventNumber[0] >> 12);
582 }
583
584 //_____________________________________________________________________________
585 UInt_t AliMonitorProcess::GetEventBunchNumber() const
586 {
587 // get the bunch number from the event id
588
589   return (fEventNumber[0] % 0x0FFF);
590 }
591
592 //_____________________________________________________________________________
593 Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName) const
594 {
595 // determine the number of events in the given raw data file
596
597   Int_t nEvents = -1;
598
599   TFile* file = TFile::Open(fileName);
600   if (!file || !file->IsOpen()) {
601     AliError(Form("could not open file %s", fileName));
602     if (file) delete file;
603     return -1;
604   }
605
606   TTree* tree = (TTree*) file->Get("RAW");
607   if (!tree) {
608     AliError("could not find tree with raw data");
609   } else {
610     nEvents = (Int_t) tree->GetEntries();
611   }
612   file->Close();
613   delete file;
614
615   return nEvents;
616 }
617
618 //_____________________________________________________________________________
619 Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader, AliESDEvent* esd)
620 {
621 // find TPC clusters and tracks
622
623   SetStatus(kRecTPC);
624
625   AliLoader* tpcLoader = fRunLoader->GetLoader("TPCLoader");
626   if (!tpcLoader) {
627     AliError("no TPC loader found");
628     return kFALSE;
629   }
630   gSystem->Unlink("TPC.RecPoints.root");
631
632   // cluster finder
633   AliDebug(1, "reconstructing clusters...");
634   tpcLoader->LoadRecPoints("recreate");
635   AliTPCclustererMI clusterer(fTPCParam);
636   tpcLoader->MakeRecPointsContainer();
637   clusterer.SetOutput(tpcLoader->TreeR());
638   clusterer.Digits2Clusters(rawReader);
639   tpcLoader->WriteRecPoints("OVERWRITE");
640
641   // track finder
642   AliDebug(1, "reconstructing tracks...");
643   AliTPCtrackerMI tracker(fTPCParam);
644   tracker.LoadClusters(tpcLoader->TreeR());
645   tracker.Clusters2Tracks(esd);
646   tracker.UnloadClusters();
647   tpcLoader->UnloadRecPoints();
648
649   return kTRUE;
650 }
651
652 //_____________________________________________________________________________
653 Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader, AliESDEvent* esd)
654 {
655 // find ITS clusters and tracks
656
657   SetStatus(kRecITS);
658
659   AliLoader* itsLoader = fRunLoader->GetLoader("ITSLoader");
660   if (!itsLoader) {
661     AliError("no ITS loader found");
662     return kFALSE;
663   }
664   gSystem->Unlink("ITS.RecPoints.root");
665
666   // cluster finder
667   AliDebug(1, "reconstructing clusters...");
668   itsLoader->LoadRecPoints("recreate");
669   AliITSclustererV2 clusterer(0);
670   itsLoader->MakeRecPointsContainer();
671   clusterer.Digits2Clusters(rawReader);
672
673   // track finder
674   AliDebug(1, "reconstructing tracks...");
675   AliITStrackerV2 tracker(0);
676   tracker.LoadClusters(itsLoader->TreeR());
677   tracker.Clusters2Tracks(esd);
678   tracker.UnloadClusters();
679
680   itsLoader->UnloadRecPoints();
681   return kTRUE;
682 }
683
684 //_____________________________________________________________________________
685 Bool_t AliMonitorProcess::ReconstructV0s(AliESDEvent* esd)
686 {
687 // find V0s
688
689   SetStatus(kRecV0s);
690
691   // V0 finder
692   AliDebug(1, "reconstructing V0s...");
693   AliV0vertexer vertexer;
694   vertexer.Tracks2V0vertices(esd);
695
696   return kTRUE;
697 }
698
699 #ifdef ENABLE_ALIMONITORPROCESS_HLT
700 //_____________________________________________________________________________
701 void AliMonitorProcess::CreateHLT(const char* fileName)
702 {
703
704 // create the HLT (Level3) object
705
706   if (fHLT) delete fHLT;
707
708   char name[256];
709   strcpy(name, fileName);
710   fHLT = new AliLevel3(name);
711   fHLT->Init("./", AliLevel3::kRaw, 1);
712
713   fHLT->SetClusterFinderParam(-1, -1, kTRUE);
714
715   Int_t phiSegments = 50;
716   Int_t etaSegments = 100;
717   Int_t trackletlength = 3;
718   Int_t tracklength = 20;//40 or 5
719   Int_t rowscopetracklet = 2;
720   Int_t rowscopetrack = 10;
721   Double_t minPtFit = 0;
722   Double_t maxangle = 0.1745;
723   Double_t goodDist = 5;
724   Double_t maxphi = 0.1;
725   Double_t maxeta = 0.1;
726   Double_t hitChi2Cut = 15;//100 or 15
727   Double_t goodHitChi2 = 5;//20 or 5
728   Double_t trackChi2Cut = 10;//50 or 10
729   fHLT->SetTrackerParam(phiSegments, etaSegments,
730                         trackletlength, tracklength,
731                         rowscopetracklet, rowscopetrack,
732                         minPtFit, maxangle, goodDist, hitChi2Cut,
733                         goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
734
735   fHLT->WriteFiles("./hlt/");
736 }
737 #endif // ENABLE_ALIMONITORPROCESS_HLT
738
739 #ifdef ENABLE_ALIMONITORPROCESS_HLT
740 //_____________________________________________________________________________
741 void AliMonitorProcess::CreateHLTHough(const char* fileName)
742 {
743
744 // create the HLT Hough transform (L3Hough) object
745
746   if (fHLTHough) delete fHLTHough;
747
748   char name[256];
749   strcpy(name, fileName);
750
751   fHLTHough = new AliHLTHough();
752   fHLTHough->SetThreshold(4);
753   fHLTHough->SetTransformerParams(140,150,0.5,-1);
754   fHLTHough->SetPeakThreshold(9000,-1);// or 6000
755   fHLTHough->Init("./", kFALSE, 50, kFALSE,0,name);
756   fHLTHough->SetAddHistograms();
757   //  fHLTHough->GetMaxFinder()->SetThreshold(14000);
758
759 }
760 #endif // ENABLE_ALIMONITORPROCESS_HLT
761
762 #ifdef ENABLE_ALIMONITORPROCESS_HLT
763 //_____________________________________________________________________________
764 Bool_t AliMonitorProcess::ReconstructHLT(Int_t iEvent)
765 {
766 // run the HLT cluster and track finder
767
768   SetStatus(kRecHLT);
769
770   gSystem->Exec("rm -rf hlt");
771   gSystem->MakeDirectory("hlt");
772   if (!fHLT) return kFALSE;
773
774   fHLT->ProcessEvent(0, 35, iEvent);
775
776   // remove the event number from the file names
777   char command[256];
778   sprintf(command, "rename points_%d points hlt/*.raw", iEvent);
779   gSystem->Exec(command);
780   sprintf(command, "rename tracks_tr_%d tracks_tr hlt/*.raw", iEvent);
781   gSystem->Exec(command);
782   sprintf(command, "rename tracks_gl_%d tracks_gl hlt/*.raw", iEvent);
783   gSystem->Exec(command);
784   sprintf(command, "rename tracks_%d tracks hlt/*.raw", iEvent);
785   gSystem->Exec(command);
786   return kTRUE;
787 }
788 #endif // ENABLE_ALIMONITORPROCESS_HLT
789
790 #ifdef ENABLE_ALIMONITORPROCESS_HLT
791 //_____________________________________________________________________________
792 Bool_t AliMonitorProcess::ReconstructHLTHough(Int_t iEvent)
793 {
794 // run the HLT Hough transformer
795
796   SetStatus(kRecHLT);
797
798   gSystem->Exec("rm -rf hlt/hough");
799   gSystem->MakeDirectory("hlt/hough");
800   gSystem->Exec("rm -rf hlt/fitter");
801   gSystem->MakeDirectory("hlt/fitter");
802   if (!fHLTHough) return kFALSE;
803
804   //  fHLTHough->Process(0, 35);
805   // Loop over TPC sectors and process the data
806   for(Int_t i=0; i<=35; i++)
807     {
808       fHLTHough->ReadData(i,iEvent);
809       fHLTHough->Transform();
810       //      if(fHLTHough->fAddHistograms)
811       fHLTHough->AddAllHistograms();
812       fHLTHough->FindTrackCandidates();
813       fHLTHough->AddTracks();
814     }
815   fHLTHough->WriteTracks("./hlt/hough");
816
817   // Run cluster fitter
818   AliHLTClusterFitter *fitter = new AliHLTClusterFitter("./hlt");
819
820   // Set debug flag for the cluster fitter
821   //  fitter->Debug();
822
823   // Setting fitter parameters
824   fitter->SetInnerWidthFactor(1,1.5);
825   fitter->SetOuterWidthFactor(1,1.5);
826   fitter->SetNmaxOverlaps(5);
827
828   //fitter->SetChiSqMax(5,kFALSE); //isolated clusters
829   fitter->SetChiSqMax(5,kTRUE);  //overlapping clusters
830
831   Int_t rowrange[2] = {0,AliHLTTransform::GetNRows()-1};
832
833   // Takes input from global hough tracks produced by HT
834   fitter->LoadSeeds(rowrange,kFALSE,iEvent);
835
836   UInt_t ndigits;
837
838   for(Int_t islice = 0; islice <= 35; islice++)
839     {
840       for(Int_t ipatch = 0; ipatch < AliHLTTransform::GetNPatches(); ipatch++)
841         {
842           // Read digits
843           fHLTHough->GetMemHandler(ipatch)->Free();
844           fHLTHough->GetMemHandler(ipatch)->Init(islice,ipatch);
845           AliHLTDigitRowData *digits = (AliHLTDigitRowData *)fHLTHough->GetMemHandler(ipatch)->AliAltroDigits2Memory(ndigits,iEvent);
846
847           fitter->Init(islice,ipatch);
848           fitter->SetInputData(digits);
849           fitter->FindClusters();
850           fitter->WriteClusters();
851         }
852     }
853
854   // Refit of the clusters
855   AliHLTVertex vertex;
856   //The seeds are the input tracks from circle HT
857   AliHLTTrackArray *tracks = fitter->GetSeeds();
858   AliHLTFitter *ft = new AliHLTFitter(&vertex,1);
859
860   ft->LoadClusters("./hlt/fitter/",iEvent,kFALSE);
861   for(Int_t i=0; i<tracks->GetNTracks(); i++)
862     {
863       AliHLTTrack *track = tracks->GetCheckedTrack(i);
864       if(!track) continue;
865       if(track->GetNHits() < 20) continue;
866       ft->SortTrackClusters(track);
867       ft->FitHelix(track);
868       track->UpdateToFirstPoint();
869     }
870   delete ft;
871
872   //Write the final tracks
873   fitter->WriteTracks(20);
874
875   delete fitter;
876
877   // remove the event number from the file names
878   char command[256];
879   sprintf(command, "rename tracks_%d tracks hlt/hough/*.raw", iEvent);
880   gSystem->Exec(command);
881   sprintf(command, "rename tracks_%d tracks hlt/fitter/*.raw", iEvent);
882   gSystem->Exec(command);
883   sprintf(command, "rename points_%d points hlt/fitter/*.raw", iEvent);
884   gSystem->Exec(command);
885   return kTRUE;
886 }
887 #endif // ENABLE_ALIMONITORPROCESS_HLT
888
889 //_____________________________________________________________________________
890 Bool_t AliMonitorProcess::WriteHistos()
891 {
892 // write the monitor tree and the monitor histograms to the file
893 // "monitor_<run number>[_<sub_run_number>].root"
894 // if at least fNEventsMin events were monitored
895
896   SetStatus(kWriting);
897
898   // rename tree file and create a new one
899   fFile->cd();
900   fTree->Write();
901   fFile->Close();
902   delete fFile;
903
904   char fileName[256];
905   sprintf(fileName, "monitor_tree_%d.root", fRunNumber);
906   if (fSubRunNumber > 0) {
907     sprintf(fileName, "monitor_tree_%d_%d.root", fRunNumber, fSubRunNumber);
908   }
909   if (fNEvents < fNEventsMin) {
910     gSystem->Unlink("monitor_tree.root");
911   } else {
912     gSystem->Rename("monitor_tree.root", fileName);
913   }
914
915   fFile = TFile::Open("monitor_tree.root", "RECREATE");
916   if (!fFile || !fFile->IsOpen()) {
917     AliFatal("could not open file for tree");
918   }
919   fTree = new TTree("MonitorTree", "tree for monitoring");
920   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
921     ((AliMonitor*) fMonitors[iMonitor])->CreateBranches(fTree);
922   }
923   gROOT->cd();
924
925   // write the histograms
926   if (fNEvents < fNEventsMin) return kTRUE;
927
928   if (!fWriteHistoList) {
929     TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
930     while (TFolder* folder = (TFolder*) iFolder->Next()) {
931       TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
932       while (AliMonitorPlot* histo = (AliMonitorPlot*) iHisto->Next()) {
933         histo->ResetList();
934       }
935       delete iHisto;
936     }
937     delete iFolder;
938   }
939
940   Bool_t result = kTRUE;
941   sprintf(fileName, "monitor_%d.root", fRunNumber);
942   if (fSubRunNumber > 0) {
943     sprintf(fileName, "monitor_%d_%d.root", fRunNumber, fSubRunNumber);
944   }
945   TFile* file = TFile::Open(fileName, "recreate");
946   if (!file || !file->IsOpen()) {
947     AliError(Form("could not open file %s", fileName));
948     result = kFALSE;
949   } else {
950     fTopFolder->Write();
951     file->Close();
952   }
953   if (file) delete file;
954
955   return result;
956 }
957
958 //_____________________________________________________________________________
959 void AliMonitorProcess::StartNewRun()
960 {
961 // reset the histograms for a new run
962
963   SetStatus(kResetting);
964   TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
965   while (TFolder* folder = (TFolder*) iFolder->Next()) {
966     TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
967     while (AliMonitorPlot* histo = (AliMonitorPlot*) iHisto->Next()) {
968       histo->Reset();
969     }
970     delete iHisto;
971   }
972   delete iFolder;
973
974   fNEvents = 0;
975 }
976
977
978 //_____________________________________________________________________________
979 void AliMonitorProcess::CheckForConnections()
980 {
981 // check if new clients want to connect and add them to the list of sockets
982
983   TSocket* socket;
984   while ((socket = fServerSocket->Accept()) != (TSocket*)-1) {
985     socket->SetOption(kNoBlock, 1);
986     char socketType[256];
987     if (socket->Recv(socketType, 255) <= 0) {
988       gSystem->Sleep(1000);
989       if (socket->Recv(socketType, 255) <= 0) {
990         TInetAddress adr = socket->GetInetAddress();
991         AliError(Form("no socket type received - "
992                       "disconnect client: %s (%s), port %d",
993                       adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
994         delete socket;
995         continue;
996       }
997     }
998     if (strcmp(socketType, "client") == 0) {
999       fSockets.Add(socket);
1000       TInetAddress adr = socket->GetInetAddress();
1001       AliInfo(Form("new client: %s (%s), port %d",
1002                    adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1003       if (fNEvents > 0) BroadcastHistos(socket);
1004     } else if (strcmp(socketType, "display") == 0) {
1005       if (fDisplaySocket) {
1006         fDisplaySocket->Close();
1007         delete fDisplaySocket;
1008       }
1009       fDisplaySocket = socket;
1010       TInetAddress adr = socket->GetInetAddress();
1011       AliInfo(Form("new display: %s (%s), port %d",
1012                    adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1013     } else {
1014       TInetAddress adr = socket->GetInetAddress();
1015       AliError(Form("unknown socket type %s - "
1016                     "disconnect client: %s (%s), port %d", socketType,
1017                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1018       delete socket;
1019       continue;
1020     }
1021   }
1022
1023   // remove finished or invalid clients
1024   for (Int_t iSocket = 0; iSocket < fSockets.GetEntriesFast(); iSocket++) {
1025     socket = (TSocket*) fSockets[iSocket];
1026     if (!socket) continue;
1027     char controlMessage[256];
1028     if (socket->Recv(controlMessage, 255)) {
1029       if (strcmp(controlMessage, "disconnect") == 0) {
1030         TInetAddress adr = socket->GetInetAddress();
1031         AliInfo(Form("disconnect client: %s (%s), port %d",
1032                      adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1033         delete fSockets.RemoveAt(iSocket);
1034         continue;
1035       }
1036     }
1037     if (!socket->IsValid()) {
1038       // remove invalid sockets from the list
1039       TInetAddress adr = socket->GetInetAddress();
1040       AliError(Form("disconnect invalid client: %s (%s), port %d",
1041                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1042       delete fSockets.RemoveAt(iSocket);
1043     }
1044   }
1045   fSockets.Compress();
1046 }
1047
1048 //_____________________________________________________________________________
1049 void AliMonitorProcess::BroadcastHistos(TSocket* toSocket)
1050 {
1051 // send the monitor histograms to the clients
1052
1053   SetStatus(kBroadcasting);
1054   TMessage message(kMESS_OBJECT);
1055   message.WriteObject(fTopFolder);
1056
1057   for (Int_t iSocket = 0; iSocket < fSockets.GetEntriesFast(); iSocket++) {
1058     TSocket* socket = (TSocket*) fSockets[iSocket];
1059     if (!socket) continue;
1060     if (toSocket && (socket != toSocket)) continue;
1061
1062     // send control message
1063     if (!socket->IsValid() || (socket->Send("histograms") <= 0)) {
1064       TInetAddress adr = socket->GetInetAddress();
1065       AliError(Form("connection to client failed - "
1066                     "disconnect client: %s (%s), port %d",
1067                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1068       delete fSockets.RemoveAt(iSocket);
1069     }
1070
1071     // receive control message
1072     char controlMessage[256];
1073     Int_t result = socket->Recv(controlMessage, 255);
1074     if (result <= 0) {
1075       gSystem->Sleep(1000);  // wait one second and try again
1076       result = socket->Recv(controlMessage, 255);
1077     }
1078     if (result <= 0) {
1079       TInetAddress adr = socket->GetInetAddress();
1080       AliError(Form("no response from client - "
1081                     "disconnect client: %s (%s), port %d",
1082                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1083       delete fSockets.RemoveAt(iSocket);
1084       continue;
1085     }
1086     if (strcmp(controlMessage, "ok") != 0) {
1087       TInetAddress adr = socket->GetInetAddress();
1088       AliError(Form("no \"ok\" message from client - "
1089                     "disconnect client: %s (%s), port %d",
1090                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1091       delete fSockets.RemoveAt(iSocket);
1092       continue;
1093     }
1094
1095     socket->SetOption(kNoBlock, 0);
1096     if (socket->Send(message) < 0) {
1097       // remove the socket from the list if there was an error
1098       TInetAddress adr = socket->GetInetAddress();
1099       AliError(Form("sending histograms failed - "
1100                     "disconnect client: %s (%s), port %d",
1101                     adr.GetHostName(), adr.GetHostAddress(), adr.GetPort()));
1102       delete fSockets.RemoveAt(iSocket);
1103     } else {
1104       gSystem->Sleep(100);
1105       socket->SetOption(kNoBlock, 1);
1106     }
1107   }
1108   fSockets.Compress();
1109 }
1110
1111
1112 //_____________________________________________________________________________
1113 AliMonitorProcess::AliMonitorInterruptHandler::AliMonitorInterruptHandler
1114   (AliMonitorProcess* process):
1115   TSignalHandler(kSigUser1, kFALSE),
1116   fProcess(process)
1117 {
1118 // constructor: set process
1119 }
1120
1121 //_____________________________________________________________________________
1122 Bool_t AliMonitorProcess::AliMonitorInterruptHandler::Notify()
1123 {
1124 // interrupt signal -> stop process
1125
1126   AliInfo("the monitoring process will be stopped.");
1127   fProcess->Stop();
1128   return kTRUE;
1129 }