MONITOR/AliMonitorProcess.cxx

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