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