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