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
  29 #include "AliMonitorProcess.h"
  30 #include "AliMonitorTPC.h"
  31 #include "AliMonitorITS.h"
  32 #include "AliMonitorV0s.h"
  33 #include "AliMonitorHLT.h"
  34 #include "AliMonitorHLTHough.h"
  35 #include "AliRawReaderRoot.h"
  36 #include "AliLoader.h"
  37 #include "AliRun.h"
  38 #include "AliTPC.h"
  39 #include "AliTPCclustererMI.h"
  40 #include "AliTPCtrackerMI.h"
  41 #include "AliITS.h"
  42 #include "AliITSclustererV2.h"
  43 #include "AliITStrackerV2.h"
  44 #include "AliITSLoader.h"
  45 #include "AliV0vertexer.h"
  46 #include <TGrid.h>
  47 #include <TSocket.h>
  48 #include <TServerSocket.h>
  49 #include <TMessage.h>
  50 #include <TGridResult.h>
  51 #include <TROOT.h>
  52 #ifdef ALI_HLT
  53 #include <AliLevel3.h>
  54 #include <AliL3Transform.h>
  55 #include <AliL3StandardIncludes.h>
  56 #include <AliL3HoughMaxFinder.h>
  57 #include <AliL3Hough.h>
  58 #endif
  59
  60 ClassImp(AliMonitorProcess)
  61
  62
  63 const Int_t AliMonitorProcess::fgkPort = 9327;
  64
  65
  66 //_____________________________________________________________________________
  67 AliMonitorProcess::AliMonitorProcess(const char* alienDir,
  68                                      const char* fileNameGalice)
  69 {
  70 // initialize the monitoring process and the monitor histograms
  71
  72   fGrid = TGrid::Connect("alien", gSystem->Getenv("USER"));
  73   if (!fGrid || fGrid->IsZombie() || !fGrid->IsConnected()) {
  74     delete fGrid;
  75     Fatal("AliMonitorProcess", "could not connect to alien");
  76   }
  77   fGrid->cd(alienDir);
  78   fLogicalFileName = "";
  79   fFileName = "";
  80
  81   fRunLoader = AliRunLoader::Open(fileNameGalice);
  82   if (!fRunLoader) Fatal("AliMonitorProcess",
  83                          "could not get run loader from file %s",
  84                          fileNameGalice);
  85
  86   fRunLoader->CdGAFile();
  87   fTPCParam = AliTPC::LoadTPCParam(gFile);
  88   if (!fTPCParam) Fatal("AliMonitorProcess", "could not load TPC parameters");
  89
  90   fRunLoader->LoadgAlice();
  91   gAlice = fRunLoader->GetAliRun();
  92   if (!gAlice) Fatal("AliMonitorProcess", "no gAlice object found");
  93   AliITS* its = (AliITS*) gAlice->GetModule("ITS");
  94   if (!its) Fatal("AliMonitorProcess", "no ITS detector found");
  95   fITSgeom = its->GetITSgeom();
  96   if (!fITSgeom) Fatal("AliMonitorProcess", "could not load ITS geometry");
  97
  98 #ifdef ALI_HLT
  99 // Init TPC parameters for HLT
 100   Bool_t isinit=AliL3Transform::Init(const_cast<char*>(fileNameGalice),kTRUE);
 101   if(!isinit){
 102     cerr << "Could not create transform settings, please check log for error messages!" << endl;
 103     return;
 104   }
 105 #endif
 106
 107   fRunNumber = 0;
 108   fSubRunNumber = 0;
 109   fNEvents = 0;
 110   fNEventsMin = 2;
 111   fWriteHistoList = kFALSE;
 112
 113   fTopFolder = new TFolder("Monitor", "monitor histograms");
 114   fTopFolder->SetOwner(kTRUE);
 115
 116   fMonitors.Add(new AliMonitorTPC(fTPCParam));
 117   fMonitors.Add(new AliMonitorITS(fITSgeom));
 118   fMonitors.Add(new AliMonitorV0s);
 119 #ifdef ALI_HLT
 120   fMonitors.Add(new AliMonitorHLT(fTPCParam));
 121   fMonitors.Add(new AliMonitorHLTHough(fTPCParam));
 122 #endif
 123
 124   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
 125     ((AliMonitor*) fMonitors[iMonitor])->CreateHistos(fTopFolder);
 126   }
 127
 128   TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
 129   while (TFolder* folder = (TFolder*) iFolder->Next()) folder->SetOwner(kTRUE);
 130   delete iFolder;
 131
 132   fFile = TFile::Open("monitor_tree.root", "RECREATE");
 133   if (!fFile || !fFile->IsOpen()) {
 134     Fatal("AliMonitorProcess", "could not open file for tree");
 135   }
 136   fTree = new TTree("MonitorTree", "tree for monitoring");
 137   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
 138     ((AliMonitor*) fMonitors[iMonitor])->CreateBranches(fTree);
 139   }
 140   gROOT->cd();
 141
 142   fServerSocket = new TServerSocket(fgkPort, kTRUE);
 143   fServerSocket->SetOption(kNoBlock, 1);
 144   fDisplaySocket = NULL;
 145   CheckForConnections();
 146 #ifdef ALI_HLT
 147   fHLT = NULL;
 148 #endif
 149
 150   SetStatus(kStopped);
 151   fStopping = kFALSE;
 152 }
 153
 154 //_____________________________________________________________________________
 155 AliMonitorProcess::AliMonitorProcess(const AliMonitorProcess& process) :
 156   TObject(process)
 157 {
 158   Fatal("AliMonitorProcess", "copy constructor not implemented");
 159 }
 160
 161 //_____________________________________________________________________________
 162 AliMonitorProcess& AliMonitorProcess::operator = (const AliMonitorProcess&
 163                                                   /*process*/)
 164 {
 165   Fatal("operator =", "assignment operator not implemented");
 166   return *this;
 167 }
 168
 169 //_____________________________________________________________________________
 170 AliMonitorProcess::~AliMonitorProcess()
 171 {
 172 // clean up
 173
 174   fMonitors.Delete();
 175   delete fTopFolder;
 176   delete fRunLoader;
 177
 178   delete fServerSocket;
 179   fSockets.Delete();
 180   delete fDisplaySocket;
 181
 182   fGrid->Close();
 183   delete fGrid;
 184
 185   fFile->Close();
 186   delete fFile;
 187   gSystem->Unlink("monitor_tree.root");
 188
 189 #ifdef ALI_HLT
 190   delete fHLT;
 191 #endif
 192 }
 193
 194
 195 //_____________________________________________________________________________
 196 const char* AliMonitorProcess::GetRevision()
 197 {
 198   return "$Revision$";
 199 }
 200
 201
 202 //_____________________________________________________________________________
 203 void AliMonitorProcess::SetStatus(EStatus status)
 204 {
 205 // set the current status and process system events
 206
 207   fStatus = status;
 208   gSystem->ProcessEvents();
 209 }
 210
 211
 212 //_____________________________________________________________________________
 213 void AliMonitorProcess::Run()
 214 {
 215 // run the monitor process:
 216 //  check for a raw data file, process the raw data file and delete it
 217
 218   fStopping = kFALSE;
 219
 220   while (!fStopping) {
 221     SetStatus(kWaiting);
 222     while (!CheckForNewFile()) {
 223       CheckForConnections();
 224       SetStatus(kWaiting);
 225       if (fStopping) break;
 226       gSystem->Sleep(10);
 227     }
 228     if (fStopping) break;
 229
 230     ProcessFile();
 231   }
 232
 233   WriteHistos();
 234
 235   fStopping = kFALSE;
 236   SetStatus(kStopped);
 237 }
 238
 239
 240 //_____________________________________________________________________________
 241 void AliMonitorProcess::Stop()
 242 {
 243 // set the fStopping flag to terminate the monitor process after the current
 244 // event was processed
 245
 246   if (GetStatus() != kStopped) fStopping = kTRUE;
 247 }
 248
 249
 250 //_____________________________________________________________________________
 251 void AliMonitorProcess::ProcessFile(const char* fileName)
 252 {
 253 // create a file with monitor histograms for a single file
 254
 255   if (GetStatus() != kStopped) {
 256     Error("ProcessFile", "ProcessFile can not be called"
 257           " while the monitor process is running");
 258     return;
 259   }
 260
 261   fFileName = fileName;
 262   Int_t nEventMin = fNEventsMin;
 263   fNEventsMin = 1;
 264   ProcessFile();
 265   WriteHistos();
 266   fNEventsMin = nEventMin;
 267   SetStatus(kStopped);
 268 }
 269
 270
 271 //_____________________________________________________________________________
 272 Bool_t AliMonitorProcess::CheckForNewFile()
 273 {
 274 // check whether a new file was registered in alien
 275
 276   TGridResult* result = fGrid->Ls();
 277   Long_t maxDate = -1;
 278   Long_t maxTime = -1;
 279   TString fileName;
 280
 281   while (const char* entry = result->Next()) {
 282     // entry = host_date_time.root
 283     TString entryCopy(entry);
 284     char* p = const_cast<char*>(entryCopy.Data());
 285     if (!strtok(p, "_") || !p) continue;  // host name
 286     char* dateStr = strtok(NULL, "_");
 287     if (!dateStr || !p) continue;
 288     char* timeStr = strtok(NULL, ".");
 289     if (!timeStr || !p) continue;
 290     Long_t date = atoi(dateStr);
 291     Long_t time = atoi(timeStr);
 292
 293     if ((date > maxDate) || ((date == maxDate) && (time > maxTime))) {
 294       maxDate = date;
 295       maxTime = time;
 296       fileName = entry;
 297     }
 298   }
 299
 300   if (maxDate < 0) return kFALSE;  // no files found
 301   if (fLogicalFileName.CompareTo(fileName) == 0) return kFALSE;  // no new file
 302
 303   fLogicalFileName = fileName;
 304   TGridResult* result2 = fGrid->GetPhysicalFileNames(fLogicalFileName.Data());
 305   fFileName = result2->Next();
 306
 307   return kTRUE;
 308 }
 309
 310 //_____________________________________________________________________________
 311 Bool_t AliMonitorProcess::ProcessFile()
 312 {
 313 // loop over all events in the raw data file, run the reconstruction
 314 // and fill the monitor histograms
 315
 316   Int_t nEvents = GetNumberOfEvents(fFileName);
 317   if (nEvents <= 0) return kFALSE;
 318   Info("ProcessFile", "found %d event(s) in file %s",
 319        nEvents, fFileName.Data());
 320 #ifdef ALI_HLT
 321   CreateHLT(fFileName);
 322   CreateHLTHough(fFileName);
 323 #endif
 324
 325   // loop over the events
 326   for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
 327     SetStatus(kReading);
 328     fRunLoader->SetEventNumber(0);
 329     AliRawReaderRoot rawReader(fFileName, iEvent);
 330     if (fStopping) break;
 331     if (rawReader.GetRunNumber() != fRunNumber) {
 332       WriteHistos();
 333       StartNewRun();
 334       fRunNumber = rawReader.GetRunNumber();
 335       fEventNumber[0] = rawReader.GetEventId()[0];
 336       fEventNumber[1] = rawReader.GetEventId()[1];
 337       fSubRunNumber = 0;
 338       if (fStopping) break;
 339     }
 340
 341     if (!ReconstructTPC(&rawReader)) return kFALSE;
 342     if (fStopping) break;
 343     if (!ReconstructITS(&rawReader)) return kFALSE;
 344     if (fStopping) break;
 345     if (!ReconstructV0s()) return kFALSE;
 346     if (fStopping) break;
 347     if (!ReconstructHLT(iEvent)) return kFALSE;
 348     if (fStopping) break;
 349     if (!ReconstructHLTHough(iEvent)) return kFALSE;
 350     if (fStopping) break;
 351
 352     if (fDisplaySocket) fDisplaySocket->Send("new event");
 353
 354     Info("ProcessFile", "filling histograms...");
 355     SetStatus(kFilling);
 356     for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
 357       ((AliMonitor*) fMonitors[iMonitor])->FillHistos(fRunLoader, &rawReader);
 358       if (fStopping) break;
 359     }
 360     if (fStopping) break;
 361
 362     Info("ProcessFile", "updating histograms...");
 363     SetStatus(kUpdating);
 364     TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
 365     while (TFolder* folder = (TFolder*) iFolder->Next()) {
 366       TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
 367       while (AliMonitorPlot* histo = (AliMonitorPlot*) iHisto->Next()) {
 368         histo->Update();
 369       }
 370       delete iHisto;
 371     }
 372     delete iFolder;
 373     if (fStopping) break;
 374
 375     Info("ProcessFile", "filling the tree...");
 376     fTree->Fill();
 377
 378     Info("ProcessFile", "broadcasting histograms...");
 379     CheckForConnections();
 380     BroadcastHistos();
 381
 382     fNEvents++;
 383     if (fStopping) break;
 384   }
 385
 386 #ifdef ALI_HLT
 387   delete fHLT;
 388   fHLT = NULL;
 389 #endif
 390
 391   return kTRUE;
 392 }
 393
 394 //_____________________________________________________________________________
 395 void AliMonitorProcess::Reset()
 396 {
 397 // write the current histograms to a file and reset them
 398
 399   if (fSubRunNumber == 0) fSubRunNumber++;
 400   WriteHistos();
 401   StartNewRun();
 402   fSubRunNumber++;
 403 }
 404
 405
 406 //_____________________________________________________________________________
 407 UInt_t AliMonitorProcess::GetEventPeriodNumber() const
 408 {
 409 // get the period number from the event id
 410
 411   return (fEventNumber[1] >> 4);
 412 }
 413
 414 //_____________________________________________________________________________
 415 UInt_t AliMonitorProcess::GetEventOrbitNumber() const
 416 {
 417 // get the orbit number from the event id
 418
 419   return ((fEventNumber[1] & 0x000F) << 20) + (fEventNumber[0] >> 12);
 420 }
 421
 422 //_____________________________________________________________________________
 423 UInt_t AliMonitorProcess::GetEventBunchNumber() const
 424 {
 425 // get the bunch number from the event id
 426
 427   return (fEventNumber[0] % 0x0FFF);
 428 }
 429
 430 //_____________________________________________________________________________
 431 Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName) const
 432 {
 433 // determine the number of events in the given raw data file
 434
 435   Int_t nEvents = -1;
 436
 437   TFile* file = TFile::Open(fileName);
 438   if (!file || !file->IsOpen()) {
 439     Error("GetNumberOfEvents", "could not open file %s", fileName);
 440     if (file) delete file;
 441     return -1;
 442   }
 443
 444   TTree* tree = (TTree*) file->Get("RAW");
 445   if (!tree) {
 446     Error("GetNumberOfEvents", "could not find tree with raw data");
 447   } else {
 448     nEvents = (Int_t) tree->GetEntries();
 449   }
 450   file->Close();
 451   delete file;
 452
 453   return nEvents;
 454 }
 455
 456 //_____________________________________________________________________________
 457 Bool_t AliMonitorProcess::ReconstructTPC(AliRawReader* rawReader)
 458 {
 459 // find TPC clusters and tracks
 460
 461   SetStatus(kRecTPC);
 462
 463   AliLoader* tpcLoader = fRunLoader->GetLoader("TPCLoader");
 464   if (!tpcLoader) {
 465     Error("ReconstructTPC", "no TPC loader found");
 466     return kFALSE;
 467   }
 468   gSystem->Unlink("TPC.RecPoints.root");
 469   gSystem->Unlink("TPC.Tracks.root");
 470
 471   // cluster finder
 472   Info("ReconstructTPC", "reconstructing clusters...");
 473   tpcLoader->LoadRecPoints("recreate");
 474   AliTPCclustererMI clusterer(fTPCParam);
 475   tpcLoader->MakeRecPointsContainer();
 476   clusterer.SetOutput(tpcLoader->TreeR());
 477   clusterer.Digits2Clusters(rawReader);
 478   tpcLoader->WriteRecPoints("OVERWRITE");
 479
 480   // track finder
 481   Info("ReconstructTPC", "reconstructing tracks...");
 482   tpcLoader->LoadTracks("recreate");
 483   {
 484     AliTPCtrackerMI tracker(fTPCParam);
 485     tracker.Clusters2Tracks();
 486   }
 487
 488   tpcLoader->UnloadRecPoints();
 489   tpcLoader->UnloadTracks();
 490   return kTRUE;
 491 }
 492
 493 //_____________________________________________________________________________
 494 Bool_t AliMonitorProcess::ReconstructITS(AliRawReader* rawReader)
 495 {
 496 // find ITS clusters and tracks
 497
 498   SetStatus(kRecITS);
 499
 500   AliLoader* itsLoader = fRunLoader->GetLoader("ITSLoader");
 501   if (!itsLoader) {
 502     Error("ReconstructITS", "no ITS loader found");
 503     return kFALSE;
 504   }
 505   AliLoader* tpcLoader = fRunLoader->GetLoader("TPCLoader");
 506   if (!tpcLoader) {
 507     Error("ReconstructITS", "no TPC loader found");
 508     return kFALSE;
 509   }
 510   gSystem->Unlink("ITS.RecPoints.root");
 511   gSystem->Unlink("ITS.Tracks.root");
 512
 513   // cluster finder
 514   Info("ReconstructITS", "reconstructing clusters...");
 515   itsLoader->LoadRecPoints("recreate");
 516   AliITSclustererV2 clusterer(fITSgeom);
 517   itsLoader->MakeRecPointsContainer();
 518   clusterer.Digits2Clusters(rawReader);
 519
 520   // track finder
 521   Info("ReconstructITS", "reconstructing tracks...");
 522   itsLoader->LoadTracks("recreate");
 523   itsLoader->MakeTracksContainer();
 524   tpcLoader->LoadTracks();
 525   AliITStrackerV2 tracker(fITSgeom);
 526   tracker.LoadClusters(itsLoader->TreeR());
 527   tracker.Clusters2Tracks(tpcLoader->TreeT(), itsLoader->TreeT());
 528   tracker.UnloadClusters();
 529   itsLoader->WriteTracks("OVERWRITE");
 530
 531   itsLoader->UnloadRecPoints();
 532   itsLoader->UnloadTracks();
 533   tpcLoader->UnloadTracks();
 534   return kTRUE;
 535 }
 536
 537 //_____________________________________________________________________________
 538 Bool_t AliMonitorProcess::ReconstructV0s()
 539 {
 540 // find V0s
 541
 542   SetStatus(kRecV0s);
 543
 544   AliITSLoader* itsLoader = (AliITSLoader*) fRunLoader->GetLoader("ITSLoader");
 545   if (!itsLoader) {
 546     Error("ReconstructV0", "no ITS loader found");
 547     return kFALSE;
 548   }
 549   gSystem->Unlink("ITS.V0s.root");
 550
 551   // V0 finder
 552   Info("ReconstructV0s", "reconstructing V0s...");
 553   itsLoader->LoadTracks("read");
 554   itsLoader->LoadV0s("recreate");
 555   AliV0vertexer vertexer;
 556   TTree* tracks = itsLoader->TreeT();
 557   if (!tracks) {
 558     Error("ReconstructV0s", "no ITS tracks tree found");
 559     return kFALSE;
 560   }
 561   if (!itsLoader->TreeV0()) itsLoader->MakeTree("V0");
 562   TTree* v0s = itsLoader->TreeV0();
 563   vertexer.Tracks2V0vertices(tracks, v0s);
 564   itsLoader->WriteV0s("OVERWRITE");
 565
 566   itsLoader->UnloadTracks();
 567   itsLoader->UnloadV0s();
 568   return kTRUE;
 569 }
 570
 571 //_____________________________________________________________________________
 572 #ifdef ALI_HLT
 573 void AliMonitorProcess::CreateHLT(const char* fileName)
 574 {
 575
 576 // create the HLT (Level3) object
 577
 578   if (fHLT) delete fHLT;
 579
 580   char name[256];
 581   strcpy(name, fileName);
 582   fHLT = new AliLevel3(name);
 583   fHLT->Init("./", AliLevel3::kRaw, 1);
 584
 585   fHLT->SetClusterFinderParam(-1, -1, kTRUE);
 586
 587   Int_t phiSegments = 50;
 588   Int_t etaSegments = 100;
 589   Int_t trackletlength = 3;
 590   Int_t tracklength = 20;//40 or 5
 591   Int_t rowscopetracklet = 2;
 592   Int_t rowscopetrack = 10;
 593   Double_t minPtFit = 0;
 594   Double_t maxangle = 0.1745;
 595   Double_t goodDist = 5;
 596   Double_t maxphi = 0.1;
 597   Double_t maxeta = 0.1;
 598   Double_t hitChi2Cut = 15;//100 or 15
 599   Double_t goodHitChi2 = 5;//20 or 5
 600   Double_t trackChi2Cut = 10;//50 or 10
 601   fHLT->SetTrackerParam(phiSegments, etaSegments,
 602                         trackletlength, tracklength,
 603                         rowscopetracklet, rowscopetrack,
 604                         minPtFit, maxangle, goodDist, hitChi2Cut,
 605                         goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
 606
 607   fHLT->WriteFiles("./hlt/");
 608 }
 609
 610 //_____________________________________________________________________________
 611 void AliMonitorProcess::CreateHLTHough(const char* fileName)
 612 {
 613
 614 // create the HLT Hough transform (L3Hough) object
 615
 616   if (fHLTHough) delete fHLTHough;
 617
 618   char name[256];
 619   strcpy(name, fileName);
 620
 621   fHLTHough = new AliL3Hough();
 622   fHLTHough->SetTransformerParams(64,64,0.1,30);
 623 //  fHLTHough->Init("./", kFALSE, 20, kFALSE,0,name);
 624   fHLTHough->SetAddHistograms();
 625   fHLTHough->GetMaxFinder()->SetThreshold(55000); // or 14000 ?
 626
 627 }
 628 #endif
 629
 630 //_____________________________________________________________________________
 631 Bool_t AliMonitorProcess::ReconstructHLT(
 632 #ifdef ALI_HLT
 633   Int_t iEvent
 634 #else
 635   Int_t /* iEvent */
 636 #endif
 637 )
 638 {
 639 // run the HLT cluster and track finder
 640
 641   SetStatus(kRecHLT);
 642
 643 #ifndef ALI_HLT
 644   Warning("ReconstructHLT", "the code was compiled without HLT support");
 645   return kTRUE;
 646
 647 #else
 648   gSystem->Exec("rm -rf hlt");
 649   gSystem->MakeDirectory("hlt");
 650   if (!fHLT) return kFALSE;
 651
 652   fHLT->ProcessEvent(0, 35, iEvent);
 653
 654   // remove the event number from the file names
 655   char command[256];
 656   sprintf(command, "rename points_%d points hlt/*.raw", iEvent);
 657   gSystem->Exec(command);
 658   sprintf(command, "rename tracks_tr_%d tracks_tr hlt/*.raw", iEvent);
 659   gSystem->Exec(command);
 660   sprintf(command, "rename tracks_gl_%d tracks_gl hlt/*.raw", iEvent);
 661   gSystem->Exec(command);
 662   sprintf(command, "rename tracks_%d tracks hlt/*.raw", iEvent);
 663   gSystem->Exec(command);
 664   return kTRUE;
 665 #endif
 666 }
 667
 668 //_____________________________________________________________________________
 669 Bool_t AliMonitorProcess::ReconstructHLTHough(
 670 #ifdef ALI_HLT
 671   Int_t iEvent
 672 #else
 673   Int_t /* iEvent */
 674 #endif
 675 )
 676 {
 677 // run the HLT Hough transformer
 678
 679   SetStatus(kRecHLT);
 680
 681 #ifndef ALI_HLT
 682   Warning("ReconstructHLTHough", "the code was compiled without HLT support");
 683   return kTRUE;
 684
 685 #else
 686   if (!fHLTHough) return kFALSE;
 687
 688   //  fHLTHough->Process(0, 35);
 689   // Loop over TPC sectors and process the data
 690   for(Int_t i=0; i<=35; i++)
 691     {
 692       fHLTHough->ReadData(i,iEvent);
 693       fHLTHough->Transform();
 694       //      if(fHLTHough->fAddHistograms)
 695       fHLTHough->AddAllHistograms();
 696       fHLTHough->FindTrackCandidates();
 697       fHLTHough->WriteTracks(i,"./hlt");
 698     }
 699   return kTRUE;
 700 #endif
 701 }
 702
 703 //_____________________________________________________________________________
 704 Bool_t AliMonitorProcess::WriteHistos()
 705 {
 706 // write the monitor tree and the monitor histograms to the file
 707 // "monitor_<run number>[_<sub_run_number>].root"
 708 // if at least fNEventsMin events were monitored
 709
 710   SetStatus(kWriting);
 711
 712   // rename tree file and create a new one
 713   fFile->cd();
 714   fTree->Write();
 715   fFile->Close();
 716   delete fFile;
 717
 718   char fileName[256];
 719   sprintf(fileName, "monitor_tree_%d.root", fRunNumber);
 720   if (fSubRunNumber > 0) {
 721     sprintf(fileName, "monitor_tree_%d_%d.root", fRunNumber, fSubRunNumber);
 722   }
 723   if (fNEvents < fNEventsMin) {
 724     gSystem->Unlink("monitor_tree.root");
 725   } else {
 726     gSystem->Rename("monitor_tree.root", fileName);
 727   }
 728
 729   fFile = TFile::Open("monitor_tree.root", "RECREATE");
 730   if (!fFile || !fFile->IsOpen()) {
 731     Fatal("WriteHistos", "could not open file for tree");
 732   }
 733   fTree = new TTree("MonitorTree", "tree for monitoring");
 734   for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
 735     ((AliMonitor*) fMonitors[iMonitor])->CreateBranches(fTree);
 736   }
 737   gROOT->cd();
 738
 739   // write the histograms
 740   if (fNEvents < fNEventsMin) return kTRUE;
 741
 742   if (!fWriteHistoList) {
 743     TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
 744     while (TFolder* folder = (TFolder*) iFolder->Next()) {
 745       TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
 746       while (AliMonitorPlot* histo = (AliMonitorPlot*) iHisto->Next()) {
 747         histo->ResetList();
 748       }
 749       delete iHisto;
 750     }
 751     delete iFolder;
 752   }
 753
 754   Bool_t result = kTRUE;
 755   sprintf(fileName, "monitor_%d.root", fRunNumber);
 756   if (fSubRunNumber > 0) {
 757     sprintf(fileName, "monitor_%d_%d.root", fRunNumber, fSubRunNumber);
 758   }
 759   TFile* file = TFile::Open(fileName, "recreate");
 760   if (!file || !file->IsOpen()) {
 761     Error("WriteHistos", "could not open file %s", fileName);
 762     result = kFALSE;
 763   } else {
 764     fTopFolder->Write();
 765     file->Close();
 766   }
 767   if (file) delete file;
 768
 769   return result;
 770 }
 771
 772 //_____________________________________________________________________________
 773 void AliMonitorProcess::StartNewRun()
 774 {
 775 // reset the histograms for a new run
 776
 777   SetStatus(kResetting);
 778   TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
 779   while (TFolder* folder = (TFolder*) iFolder->Next()) {
 780     TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
 781     while (AliMonitorPlot* histo = (AliMonitorPlot*) iHisto->Next()) {
 782       histo->Reset();
 783     }
 784     delete iHisto;
 785   }
 786   delete iFolder;
 787
 788   fNEvents = 0;
 789 }
 790
 791
 792 //_____________________________________________________________________________
 793 void AliMonitorProcess::CheckForConnections()
 794 {
 795 // check if new clients want to connect and add them to the list of sockets
 796
 797   TMessage message(kMESS_OBJECT);
 798   message.WriteObject(fTopFolder);
 799   SetStatus(kConnecting);
 800
 801   TSocket* socket;
 802   while ((socket = fServerSocket->Accept()) != (TSocket*)-1) {
 803     socket->SetOption(kNoBlock, 1);
 804     char socketType[256];
 805     if (!socket->Recv(socketType, 255)) continue;
 806     if (strcmp(socketType, "client") == 0) {
 807       if ((fNEvents == 0) || (socket->Send(message) >= 0)) {
 808         fSockets.Add(socket);
 809         TInetAddress adr = socket->GetInetAddress();
 810         Info("CheckForConnections", "new client:\n %s (%s), port %d\n",
 811              adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
 812       }
 813     } else if (strcmp(socketType, "display") == 0) {
 814       if (fDisplaySocket) {
 815         fDisplaySocket->Close();
 816         delete fDisplaySocket;
 817       }
 818       fDisplaySocket = socket;
 819       fDisplaySocket->SetOption(kNoBlock, 1);
 820       TInetAddress adr = socket->GetInetAddress();
 821       Info("CheckForConnections", "new display:\n %s (%s), port %d\n",
 822            adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
 823     }
 824   }
 825
 826   for (Int_t iSocket = 0; iSocket < fSockets.GetEntriesFast(); iSocket++) {
 827     socket = (TSocket*) fSockets[iSocket];
 828     if (!socket) continue;
 829     // remove finished client
 830     char str[256];
 831     if (socket->Recv(str, 255)) {
 832       TString socketMessage(str);
 833       if(socketMessage.CompareTo("Finished") == 0) {
 834         TInetAddress adr = socket->GetInetAddress();
 835         Info("CheckForConnections",
 836              "disconnect finished client:\n %s (%s), port %d\n",
 837              adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
 838         delete fSockets.RemoveAt(iSocket);
 839         continue;
 840       }
 841     }
 842     if (!socket->IsValid()) {
 843       // remove invalid sockets from the list
 844       TInetAddress adr = socket->GetInetAddress();
 845       Info("BroadcastHistos", "disconnect client:\n %s (%s), port %d\n",
 846            adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
 847       delete fSockets.RemoveAt(iSocket);
 848     }
 849   }
 850   fSockets.Compress();
 851 }
 852
 853 //_____________________________________________________________________________
 854 void AliMonitorProcess::BroadcastHistos()
 855 {
 856 // send the monitor histograms to the clients
 857
 858   SetStatus(kBroadcasting);
 859   TMessage message(kMESS_OBJECT);
 860   message.WriteObject(fTopFolder);
 861
 862   for (Int_t iSocket = 0; iSocket < fSockets.GetEntriesFast(); iSocket++) {
 863     TSocket* socket = (TSocket*) fSockets[iSocket];
 864     if (!socket) continue;
 865     socket->SetOption(kNoBlock, 0);
 866     if (!socket->IsValid() || (socket->Send(message) < 0)) {
 867       // remove the socket from the list if there was an error
 868       TInetAddress adr = socket->GetInetAddress();
 869       Info("BroadcastHistos", "disconnect client:\n %s (%s), port %d\n",
 870            adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
 871       delete fSockets.RemoveAt(iSocket);
 872     } else {
 873       socket->SetOption(kNoBlock, 1);
 874     }
 875   }
 876   fSockets.Compress();
 877 }