#include "AliMonitorTPC.h"
#include "AliMonitorITS.h"
#include "AliMonitorV0s.h"
+#include "AliMonitorHLT.h"
+#include "AliMonitorHLTHough.h"
#include "AliRawReaderRoot.h"
#include "AliLoader.h"
#include "AliRun.h"
#include "AliITStrackerV2.h"
#include "AliITSLoader.h"
#include "AliV0vertexer.h"
-#include <TSystem.h>
+#include <TGrid.h>
#include <TSocket.h>
+#include <TServerSocket.h>
#include <TMessage.h>
#include <TGridResult.h>
#include <TROOT.h>
-
+#ifdef ALI_HLT
+#include <AliLevel3.h>
+#include <AliL3Transform.h>
+#include <AliL3Track.h>
+#include <AliL3TrackArray.h>
+#include <AliL3StandardIncludes.h>
+#include <AliL3HoughMaxFinder.h>
+#include <AliL3HoughBaseTransformer.h>
+#include <AliL3Hough.h>
+#include <AliL3ClusterFitter.h>
+#include <AliL3Vertex.h>
+#include <AliL3Fitter.h>
+#include <AliL3DDLDataFileHandler.h>
+#endif
ClassImp(AliMonitorProcess)
-const Int_t AliMonitorProcess::kgPort = 9327;
+const Int_t AliMonitorProcess::fgkPort = 9327;
//_____________________________________________________________________________
-AliMonitorProcess::AliMonitorProcess(const char* alienDir,
+AliMonitorProcess::AliMonitorProcess(
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
+ const char* /*alienHost*/,
+#else
+ const char* alienHost,
+#endif
+ const char* alienDir,
const char* fileNameGalice)
{
// initialize the monitoring process and the monitor histograms
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
fGrid = TGrid::Connect("alien", gSystem->Getenv("USER"));
+#else
+ fGrid = TGrid::Connect(alienHost, gSystem->Getenv("USER"));
+#endif
if (!fGrid || fGrid->IsZombie() || !fGrid->IsConnected()) {
delete fGrid;
Fatal("AliMonitorProcess", "could not connect to alien");
}
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
fGrid->cd(alienDir);
+#else
+ fAlienDir = alienDir;
+#endif
fLogicalFileName = "";
fFileName = "";
fRunLoader->LoadgAlice();
gAlice = fRunLoader->GetAliRun();
if (!gAlice) Fatal("AliMonitorProcess", "no gAlice object found");
- AliITS* ITS = (AliITS*) gAlice->GetModule("ITS");
- if (!ITS) Fatal("AliMonitorProcess", "no ITS detector found");
- fITSgeom = ITS->GetITSgeom();
+ AliITS* its = (AliITS*) gAlice->GetModule("ITS");
+ if (!its) Fatal("AliMonitorProcess", "no ITS detector found");
+ fITSgeom = its->GetITSgeom();
if (!fITSgeom) Fatal("AliMonitorProcess", "could not load ITS geometry");
+#ifdef ALI_HLT
+// Init TPC parameters for HLT
+ Bool_t isinit=AliL3Transform::Init(const_cast<char*>(fileNameGalice),kTRUE);
+ if(!isinit){
+ cerr << "Could not create transform settings, please check log for error messages!" << endl;
+ return;
+ }
+#endif
+
fRunNumber = 0;
fSubRunNumber = 0;
fNEvents = 0;
- fNEventsMin = 2;
+ fNEventsMin = 1;
fWriteHistoList = kFALSE;
fTopFolder = new TFolder("Monitor", "monitor histograms");
fMonitors.Add(new AliMonitorTPC(fTPCParam));
fMonitors.Add(new AliMonitorITS(fITSgeom));
fMonitors.Add(new AliMonitorV0s);
+#ifdef ALI_HLT
+ fMonitors.Add(new AliMonitorHLT(fTPCParam));
+ fMonitors.Add(new AliMonitorHLTHough(fTPCParam));
+#endif
for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
((AliMonitor*) fMonitors[iMonitor])->CreateHistos(fTopFolder);
}
gROOT->cd();
- fServerSocket = new TServerSocket(kgPort, kTRUE);
+ fServerSocket = new TServerSocket(fgkPort, kTRUE);
fServerSocket->SetOption(kNoBlock, 1);
fDisplaySocket = NULL;
CheckForConnections();
+#ifdef ALI_HLT
+ fHLT = NULL;
+#endif
- fStatus = kStopped;
+ SetStatus(kStopped);
fStopping = kFALSE;
+
+ fInterruptHandler = new AliMonitorInterruptHandler(this);
+ gSystem->AddSignalHandler(fInterruptHandler);
+}
+
+//_____________________________________________________________________________
+AliMonitorProcess::AliMonitorProcess(const AliMonitorProcess& process) :
+ TObject(process)
+{
+ Fatal("AliMonitorProcess", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorProcess& AliMonitorProcess::operator = (const AliMonitorProcess&
+ /*process*/)
+{
+ Fatal("operator =", "assignment operator not implemented");
+ return *this;
}
//_____________________________________________________________________________
fSockets.Delete();
delete fDisplaySocket;
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
fGrid->Close();
+#endif
delete fGrid;
fFile->Close();
delete fFile;
gSystem->Unlink("monitor_tree.root");
+
+#ifdef ALI_HLT
+ delete fHLT;
+ delete fHLTHough;
+#endif
+
+ gSystem->RemoveSignalHandler(fInterruptHandler);
+ delete fInterruptHandler;
}
}
+//_____________________________________________________________________________
+void AliMonitorProcess::SetStatus(EStatus status)
+{
+// set the current status and process system events
+
+ fStatus = status;
+ gSystem->ProcessEvents();
+}
+
+
//_____________________________________________________________________________
void AliMonitorProcess::Run()
{
fStopping = kFALSE;
while (!fStopping) {
- fStatus = kWaiting;
+ SetStatus(kWaiting);
while (!CheckForNewFile()) {
CheckForConnections();
- fStatus = kWaiting;
+ SetStatus(kWaiting);
if (fStopping) break;
gSystem->Sleep(10);
}
WriteHistos();
fStopping = kFALSE;
- fStatus = kStopped;
+ SetStatus(kStopped);
}
// set the fStopping flag to terminate the monitor process after the current
// event was processed
- if (fStatus != kStopped) fStopping = kTRUE;
+ if (GetStatus() != kStopped) fStopping = kTRUE;
}
{
// create a file with monitor histograms for a single file
- if (fStatus != kStopped) {
+ if (GetStatus() != kStopped) {
Error("ProcessFile", "ProcessFile can not be called"
" while the monitor process is running");
return;
ProcessFile();
WriteHistos();
fNEventsMin = nEventMin;
- fStatus = kStopped;
+ SetStatus(kStopped);
}
{
// check whether a new file was registered in alien
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
TGridResult* result = fGrid->Ls();
+#else
+ TDatime datime;
+ char dirName[256];
+ sprintf(dirName, "%s/adc-%d", fAlienDir.Data(), datime.GetDate());
+ char findName[256];
+ sprintf(findName, "*.root");
+ Grid_ResultHandle_t handle = fGrid->Find(dirName, findName);
+ if (!handle) {
+ Error("CheckForNewFile", "could not open alien directory %s",
+ dirName);
+ return kFALSE;
+ }
+ TGridResult* result = fGrid->CreateGridResult(handle);
+#endif
Long_t maxDate = -1;
Long_t maxTime = -1;
TString fileName;
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
while (const char* entry = result->Next()) {
+#else
+ while (Grid_Result_t* resultEntry = result->Next()) {
+ const char* entry = resultEntry->name.c_str();
+#endif
+ if (strrchr(entry, '/')) entry = strrchr(entry, '/')+1;
// entry = host_date_time.root
TString entryCopy(entry);
char* p = const_cast<char*>(entryCopy.Data());
- if (!strsep(&p, "_") || !p) continue; // host name
- char* dateStr = strsep(&p, "_");
+ if (!strtok(p, "_") || !p) continue; // host name
+ char* dateStr = strtok(NULL, "_");
if (!dateStr || !p) continue;
- char* timeStr = strsep(&p, ".");
+ char* timeStr = strtok(NULL, ".");
if (!timeStr || !p) continue;
Long_t date = atoi(dateStr);
Long_t time = atoi(timeStr);
}
}
+ delete result;
if (maxDate < 0) return kFALSE; // no files found
if (fLogicalFileName.CompareTo(fileName) == 0) return kFALSE; // no new file
fLogicalFileName = fileName;
- fFileName = fGrid->GetPhysicalFileName(fLogicalFileName.Data());
+#if ROOT_VERSION_CODE <= 199169 // 3.10/01
+ result = fGrid->GetPhysicalFileNames(fLogicalFileName.Data());
+ fFileName = result->Next();
+#else
+ fileName = dirName + ("/" + fLogicalFileName);
+ handle = fGrid->GetPhysicalFileNames(fileName.Data());
+ if (!handle) {
+ Error("CheckForNewFile", "could not get physical file names for %s",
+ fileName.Data());
+ return kFALSE;
+ }
+ result = fGrid->CreateGridResult(handle);
+ result->Reset();
+ Grid_Result_t* resultEntry = result->Next();
+ if (!resultEntry) {
+ Error("CheckForNewFile", "could not get physical file names for %s",
+ fileName.Data());
+ return kFALSE;
+ }
+ fFileName = resultEntry->name2.c_str();
+ fFileName.ReplaceAll("castor:/", "rfio:/");
+#endif
+ delete result;
+
return kTRUE;
}
if (nEvents <= 0) return kFALSE;
Info("ProcessFile", "found %d event(s) in file %s",
nEvents, fFileName.Data());
+#ifdef ALI_HLT
+ CreateHLT(fFileName);
+ CreateHLTHough(fFileName);
+#endif
// loop over the events
for (Int_t iEvent = 0; iEvent < nEvents; iEvent++) {
- fStatus = kReading;
+ CheckForConnections();
+ SetStatus(kReading);
fRunLoader->SetEventNumber(0);
AliRawReaderRoot rawReader(fFileName, iEvent);
if (fStopping) break;
if (fStopping) break;
}
+ // monitor only central physics events
+ if (rawReader.GetType() != 7) continue;
+ if ((rawReader.GetAttributes()[0] & 0x02) == 0) continue;
+ Info("ProcessFile", "run: %d event: %d %d\n", rawReader.GetRunNumber(),
+ rawReader.GetEventId()[0], rawReader.GetEventId()[1]);
+
+ CheckForConnections();
if (!ReconstructTPC(&rawReader)) return kFALSE;
if (fStopping) break;
+ CheckForConnections();
if (!ReconstructITS(&rawReader)) return kFALSE;
if (fStopping) break;
+ CheckForConnections();
if (!ReconstructV0s()) return kFALSE;
if (fStopping) break;
+ CheckForConnections();
+ if (!ReconstructHLT(iEvent)) return kFALSE;
+ if (fStopping) break;
+ CheckForConnections();
+ if (!ReconstructHLTHough(iEvent)) return kFALSE;
+ if (fStopping) break;
if (fDisplaySocket) fDisplaySocket->Send("new event");
Info("ProcessFile", "filling histograms...");
- fStatus = kFilling;
for (Int_t iMonitor = 0; iMonitor < fMonitors.GetEntriesFast(); iMonitor++) {
+ CheckForConnections();
+ SetStatus(kFilling);
((AliMonitor*) fMonitors[iMonitor])->FillHistos(fRunLoader, &rawReader);
if (fStopping) break;
}
if (fStopping) break;
Info("ProcessFile", "updating histograms...");
- fStatus = kUpdating;
+ CheckForConnections();
+ SetStatus(kUpdating);
TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
while (TFolder* folder = (TFolder*) iFolder->Next()) {
TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
if (fStopping) break;
}
+#ifdef ALI_HLT
+ delete fHLT;
+ fHLT = NULL;
+#endif
+
return kTRUE;
}
//_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventPeriodNumber()
+UInt_t AliMonitorProcess::GetEventPeriodNumber() const
{
// get the period number from the event id
}
//_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventOrbitNumber()
+UInt_t AliMonitorProcess::GetEventOrbitNumber() const
{
// get the orbit number from the event id
}
//_____________________________________________________________________________
-UInt_t AliMonitorProcess::GetEventBunchNumber()
+UInt_t AliMonitorProcess::GetEventBunchNumber() const
{
// get the bunch number from the event id
}
//_____________________________________________________________________________
-Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName)
+Int_t AliMonitorProcess::GetNumberOfEvents(const char* fileName) const
{
// determine the number of events in the given raw data file
{
// find TPC clusters and tracks
- fStatus = kRecTPC;
+ SetStatus(kRecTPC);
AliLoader* tpcLoader = fRunLoader->GetLoader("TPCLoader");
if (!tpcLoader) {
tpcLoader->LoadTracks("recreate");
{
AliTPCtrackerMI tracker(fTPCParam);
+ tracker.SetIO();
+ tracker.LoadClusters();
tracker.Clusters2Tracks();
+ tracker.WriteTracks();
+ tracker.UnloadClusters();
+ tpcLoader->WriteTracks("OVERWRITE");
}
tpcLoader->UnloadRecPoints();
{
// find ITS clusters and tracks
- fStatus = kRecITS;
+ SetStatus(kRecITS);
AliLoader* itsLoader = fRunLoader->GetLoader("ITSLoader");
if (!itsLoader) {
{
// find V0s
- fStatus = kRecV0s;
+ SetStatus(kRecV0s);
AliITSLoader* itsLoader = (AliITSLoader*) fRunLoader->GetLoader("ITSLoader");
if (!itsLoader) {
return kTRUE;
}
+//_____________________________________________________________________________
+#ifdef ALI_HLT
+void AliMonitorProcess::CreateHLT(const char* fileName)
+{
+
+// create the HLT (Level3) object
+
+ if (fHLT) delete fHLT;
+
+ char name[256];
+ strcpy(name, fileName);
+ fHLT = new AliLevel3(name);
+ fHLT->Init("./", AliLevel3::kRaw, 1);
+
+ fHLT->SetClusterFinderParam(-1, -1, kTRUE);
+
+ Int_t phiSegments = 50;
+ Int_t etaSegments = 100;
+ Int_t trackletlength = 3;
+ Int_t tracklength = 20;//40 or 5
+ Int_t rowscopetracklet = 2;
+ Int_t rowscopetrack = 10;
+ Double_t minPtFit = 0;
+ Double_t maxangle = 0.1745;
+ Double_t goodDist = 5;
+ Double_t maxphi = 0.1;
+ Double_t maxeta = 0.1;
+ Double_t hitChi2Cut = 15;//100 or 15
+ Double_t goodHitChi2 = 5;//20 or 5
+ Double_t trackChi2Cut = 10;//50 or 10
+ fHLT->SetTrackerParam(phiSegments, etaSegments,
+ trackletlength, tracklength,
+ rowscopetracklet, rowscopetrack,
+ minPtFit, maxangle, goodDist, hitChi2Cut,
+ goodHitChi2, trackChi2Cut, 50, maxphi, maxeta, kTRUE);
+
+ fHLT->WriteFiles("./hlt/");
+}
+
+//_____________________________________________________________________________
+void AliMonitorProcess::CreateHLTHough(const char* fileName)
+{
+
+// create the HLT Hough transform (L3Hough) object
+
+ if (fHLTHough) delete fHLTHough;
+
+ char name[256];
+ strcpy(name, fileName);
+
+ fHLTHough = new AliL3Hough();
+ fHLTHough->SetThreshold(4);
+ fHLTHough->SetTransformerParams(140,150,0.5,-1);
+ fHLTHough->SetPeakThreshold(9000,-1);// or 6000
+ fHLTHough->Init("./", kFALSE, 50, kFALSE,0,name);
+ fHLTHough->SetAddHistograms();
+ // fHLTHough->GetMaxFinder()->SetThreshold(14000);
+
+}
+#endif
+
+//_____________________________________________________________________________
+Bool_t AliMonitorProcess::ReconstructHLT(
+#ifdef ALI_HLT
+ Int_t iEvent
+#else
+ Int_t /* iEvent */
+#endif
+)
+{
+// run the HLT cluster and track finder
+
+ SetStatus(kRecHLT);
+
+#ifndef ALI_HLT
+ Warning("ReconstructHLT", "the code was compiled without HLT support");
+ return kTRUE;
+
+#else
+ gSystem->Exec("rm -rf hlt");
+ gSystem->MakeDirectory("hlt");
+ if (!fHLT) return kFALSE;
+
+ fHLT->ProcessEvent(0, 35, iEvent);
+
+ // remove the event number from the file names
+ char command[256];
+ sprintf(command, "rename points_%d points hlt/*.raw", iEvent);
+ gSystem->Exec(command);
+ sprintf(command, "rename tracks_tr_%d tracks_tr hlt/*.raw", iEvent);
+ gSystem->Exec(command);
+ sprintf(command, "rename tracks_gl_%d tracks_gl hlt/*.raw", iEvent);
+ gSystem->Exec(command);
+ sprintf(command, "rename tracks_%d tracks hlt/*.raw", iEvent);
+ gSystem->Exec(command);
+ return kTRUE;
+#endif
+}
+
+//_____________________________________________________________________________
+Bool_t AliMonitorProcess::ReconstructHLTHough(
+#ifdef ALI_HLT
+ Int_t iEvent
+#else
+ Int_t /* iEvent */
+#endif
+)
+{
+// run the HLT Hough transformer
+
+ SetStatus(kRecHLT);
+
+#ifndef ALI_HLT
+ Warning("ReconstructHLTHough", "the code was compiled without HLT support");
+ return kTRUE;
+
+#else
+ gSystem->Exec("rm -rf hlt/hough");
+ gSystem->MakeDirectory("hlt/hough");
+ gSystem->Exec("rm -rf hlt/fitter");
+ gSystem->MakeDirectory("hlt/fitter");
+ if (!fHLTHough) return kFALSE;
+
+ // fHLTHough->Process(0, 35);
+ // Loop over TPC sectors and process the data
+ for(Int_t i=0; i<=35; i++)
+ {
+ fHLTHough->ReadData(i,iEvent);
+ fHLTHough->Transform();
+ // if(fHLTHough->fAddHistograms)
+ fHLTHough->AddAllHistograms();
+ fHLTHough->FindTrackCandidates();
+ fHLTHough->AddTracks();
+ }
+ fHLTHough->WriteTracks("./hlt/hough");
+
+ // Run cluster fitter
+ AliL3ClusterFitter *fitter = new AliL3ClusterFitter("./hlt");
+
+ // Set debug flag for the cluster fitter
+ // fitter->Debug();
+
+ // Setting fitter parameters
+ fitter->SetInnerWidthFactor(1,1.5);
+ fitter->SetOuterWidthFactor(1,1.5);
+ fitter->SetNmaxOverlaps(5);
+
+ //fitter->SetChiSqMax(5,kFALSE); //isolated clusters
+ fitter->SetChiSqMax(5,kTRUE); //overlapping clusters
+
+ Int_t rowrange[2] = {0,AliL3Transform::GetNRows()-1};
+
+ // Takes input from global hough tracks produced by HT
+ fitter->LoadSeeds(rowrange,kFALSE,iEvent);
+
+ UInt_t ndigits;
+
+ for(Int_t islice = 0; islice <= 35; islice++)
+ {
+ for(Int_t ipatch = 0; ipatch < AliL3Transform::GetNPatches(); ipatch++)
+ {
+ // Read digits
+ fHLTHough->GetMemHandler(ipatch)->Free();
+ fHLTHough->GetMemHandler(ipatch)->Init(islice,ipatch);
+ AliL3DigitRowData *digits = (AliL3DigitRowData *)fHLTHough->GetMemHandler(ipatch)->AliAltroDigits2Memory(ndigits,iEvent);
+
+ fitter->Init(islice,ipatch);
+ fitter->SetInputData(digits);
+ fitter->FindClusters();
+ fitter->WriteClusters();
+ }
+ }
+
+ // Refit of the clusters
+ AliL3Vertex vertex;
+ //The seeds are the input tracks from circle HT
+ AliL3TrackArray *tracks = fitter->GetSeeds();
+ AliL3Fitter *ft = new AliL3Fitter(&vertex,1);
+
+ ft->LoadClusters("./hlt/fitter/",iEvent,kFALSE);
+ for(Int_t i=0; i<tracks->GetNTracks(); i++)
+ {
+ AliL3Track *track = tracks->GetCheckedTrack(i);
+ if(!track) continue;
+ if(track->GetNHits() < 20) continue;
+ ft->SortTrackClusters(track);
+ ft->FitHelix(track);
+ track->UpdateToFirstPoint();
+ }
+ delete ft;
+
+ //Write the final tracks
+ fitter->WriteTracks(20);
+
+ delete fitter;
+
+ // remove the event number from the file names
+ char command[256];
+ sprintf(command, "rename tracks_%d tracks hlt/hough/*.raw", iEvent);
+ gSystem->Exec(command);
+ sprintf(command, "rename tracks_%d tracks hlt/fitter/*.raw", iEvent);
+ gSystem->Exec(command);
+ sprintf(command, "rename points_%d points hlt/fitter/*.raw", iEvent);
+ gSystem->Exec(command);
+ return kTRUE;
+#endif
+}
//_____________________________________________________________________________
Bool_t AliMonitorProcess::WriteHistos()
// "monitor_<run number>[_<sub_run_number>].root"
// if at least fNEventsMin events were monitored
- fStatus = kWriting;
+ SetStatus(kWriting);
// rename tree file and create a new one
fFile->cd();
{
// reset the histograms for a new run
- fStatus = kResetting;
+ SetStatus(kResetting);
TIterator* iFolder = fTopFolder->GetListOfFolders()->MakeIterator();
while (TFolder* folder = (TFolder*) iFolder->Next()) {
TIterator* iHisto = folder->GetListOfFolders()->MakeIterator();
{
// check if new clients want to connect and add them to the list of sockets
- TMessage message(kMESS_OBJECT);
- message.WriteObject(fTopFolder);
- fStatus = kConnecting;
-
TSocket* socket;
while ((socket = fServerSocket->Accept()) != (TSocket*)-1) {
+ socket->SetOption(kNoBlock, 1);
char socketType[256];
- if (!socket->Recv(socketType, 255)) continue;
- if (strcmp(socketType, "client") == 0) {
- if ((fNEvents == 0) || (socket->Send(message) >= 0)) {
- fSockets.Add(socket);
+ if (socket->Recv(socketType, 255) <= 0) {
+ gSystem->Sleep(1000);
+ if (socket->Recv(socketType, 255) <= 0) {
TInetAddress adr = socket->GetInetAddress();
- Info("CheckForConnections", "new client:\n %s (%s), port %d\n",
- adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ Error("CheckForConnections", "no socket type received - "
+ "disconnect client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ delete socket;
+ continue;
}
+ }
+ if (strcmp(socketType, "client") == 0) {
+ fSockets.Add(socket);
+ TInetAddress adr = socket->GetInetAddress();
+ Info("CheckForConnections", "new client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ if (fNEvents > 0) BroadcastHistos(socket);
} else if (strcmp(socketType, "display") == 0) {
if (fDisplaySocket) {
fDisplaySocket->Close();
delete fDisplaySocket;
}
fDisplaySocket = socket;
- fDisplaySocket->SetOption(kNoBlock, 1);
TInetAddress adr = socket->GetInetAddress();
Info("CheckForConnections", "new display:\n %s (%s), port %d\n",
adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ } else {
+ TInetAddress adr = socket->GetInetAddress();
+ Error("CheckForConnections", "unknown socket type %s - "
+ "disconnect client:\n %s (%s), port %d\n", socketType,
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ delete socket;
+ continue;
}
}
+ // remove finished or invalid clients
for (Int_t iSocket = 0; iSocket < fSockets.GetEntriesFast(); iSocket++) {
socket = (TSocket*) fSockets[iSocket];
if (!socket) continue;
+ char controlMessage[256];
+ if (socket->Recv(controlMessage, 255)) {
+ if (strcmp(controlMessage, "disconnect") == 0) {
+ TInetAddress adr = socket->GetInetAddress();
+ Info("CheckForConnections",
+ "disconnect client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ delete fSockets.RemoveAt(iSocket);
+ continue;
+ }
+ }
if (!socket->IsValid()) {
// remove invalid sockets from the list
TInetAddress adr = socket->GetInetAddress();
- Info("BroadcastHistos", "disconnect client:\n %s (%s), port %d\n",
- adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ Error("CheckForConnections",
+ "disconnect invalid client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
delete fSockets.RemoveAt(iSocket);
}
}
}
//_____________________________________________________________________________
-void AliMonitorProcess::BroadcastHistos()
+void AliMonitorProcess::BroadcastHistos(TSocket* toSocket)
{
// send the monitor histograms to the clients
- fStatus = kBroadcasting;
+ SetStatus(kBroadcasting);
TMessage message(kMESS_OBJECT);
message.WriteObject(fTopFolder);
for (Int_t iSocket = 0; iSocket < fSockets.GetEntriesFast(); iSocket++) {
TSocket* socket = (TSocket*) fSockets[iSocket];
if (!socket) continue;
- if (!socket->IsValid() || (socket->Send(message) < 0)) {
+ if (toSocket && (socket != toSocket)) continue;
+
+ // send control message
+ if (!socket->IsValid() || (socket->Send("histograms") <= 0)) {
+ TInetAddress adr = socket->GetInetAddress();
+ Error("BroadcastHistos", "connection to client failed - "
+ "disconnect client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ delete fSockets.RemoveAt(iSocket);
+ }
+
+ // receive control message
+ char controlMessage[256];
+ Int_t result = socket->Recv(controlMessage, 255);
+ if (result <= 0) {
+ gSystem->Sleep(1000); // wait one second and try again
+ result = socket->Recv(controlMessage, 255);
+ }
+ if (result <= 0) {
+ TInetAddress adr = socket->GetInetAddress();
+ Error("BroadcastHistos", "no response from client - "
+ "disconnect client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ delete fSockets.RemoveAt(iSocket);
+ continue;
+ }
+ if (strcmp(controlMessage, "ok") != 0) {
+ TInetAddress adr = socket->GetInetAddress();
+ Error("BroadcastHistos", "no \"ok\" message from client - "
+ "disconnect client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ delete fSockets.RemoveAt(iSocket);
+ continue;
+ }
+
+ socket->SetOption(kNoBlock, 0);
+ if (socket->Send(message) < 0) {
// remove the socket from the list if there was an error
TInetAddress adr = socket->GetInetAddress();
- Info("BroadcastHistos", "disconnect client:\n %s (%s), port %d\n",
- adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
+ Error("BroadcastHistos", "sending histograms failed - "
+ "disconnect client:\n %s (%s), port %d\n",
+ adr.GetHostName(), adr.GetHostAddress(), adr.GetPort());
delete fSockets.RemoveAt(iSocket);
+ } else {
+ gSystem->Sleep(100);
+ socket->SetOption(kNoBlock, 1);
}
}
fSockets.Compress();
}
+
+
+//_____________________________________________________________________________
+AliMonitorProcess::AliMonitorInterruptHandler::AliMonitorInterruptHandler
+ (AliMonitorProcess* process):
+ TSignalHandler(kSigUser1, kFALSE),
+ fProcess(process)
+{
+// constructor: set process
+}
+
+//_____________________________________________________________________________
+AliMonitorProcess::AliMonitorInterruptHandler::AliMonitorInterruptHandler
+ (const AliMonitorInterruptHandler& handler):
+ TSignalHandler(handler)
+{
+// copy constructor
+
+ Fatal("AliMonitorInterruptHandler", "copy constructor not implemented");
+}
+
+//_____________________________________________________________________________
+AliMonitorProcess::AliMonitorInterruptHandler&
+ AliMonitorProcess::AliMonitorInterruptHandler::operator =
+ (const AliMonitorInterruptHandler& /*handler*/)
+{
+// assignment operator
+
+ Fatal("operator =", "assignment operator not implemented");
+ return *this;
+}
+
+//_____________________________________________________________________________
+Bool_t AliMonitorProcess::AliMonitorInterruptHandler::Notify()
+{
+// interrupt signal -> stop process
+
+ Info("Notify", "the monitoring process will be stopped.");
+ fProcess->Stop();
+ return kTRUE;
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff