---

/Go4AnalysisClient/TGo4AnalysisMainRunnable.cxx

Go to the documentation of this file.

//---------------------------------------------------------------
//        Go4 Release Package v2.10-5 (build 21005) 
//                      03-Nov-2005
//---------------------------------------------------------------
//       The GSI Online Offline Object Oriented (Go4) Project
//       Experiment Data Processing at DVEE department, GSI
//---------------------------------------------------------------
//
//Copyright (C) 2000- Gesellschaft f. Schwerionenforschung, GSI
//                    Planckstr. 1, 64291 Darmstadt, Germany
//Contact:            http://go4.gsi.de
//----------------------------------------------------------------
//This software can be used under the license agreements as stated
//in Go4License.txt file which is part of the distribution.
//----------------------------------------------------------------
#include "TGo4AnalysisMainRunnable.h"

#include <iostream.h>
#include <stdexcept>

#include "Go4Log/TGo4Log.h"
#include "Go4LockGuard/TGo4LockGuard.h"

#include "Go4AnalysisClient/TGo4AnalysisClientImp.h"
#include "Go4Analysis/TGo4AnalysisStepException.h"
#include "Go4Analysis/TGo4UserException.h"
#include "Go4Analysis/TGo4AnalysisImp.h"
#include "Go4CommandsBase/TGo4CommandInvoker.h"
#include "Go4Event/TGo4EventErrorException.h"
#include "Go4Event/TGo4EventTimeoutException.h"
#include "Go4Event/TGo4EventEndException.h"
#include "Go4DynamicList/TGo4DynamicListException.h"

const UInt_t TGo4AnalysisMainRunnable::fguPOLLINTERVAL=1000;

TGo4AnalysisMainRunnable::TGo4AnalysisMainRunnable(const char* name, TGo4AnalysisClient* cli)
: TGo4Runnable(name,cli->GetTask()), fxAnalysisClient(cli)
{
   fxAnalysis=cli->GetAnalysis();
}

TGo4AnalysisMainRunnable::~TGo4AnalysisMainRunnable()
{

}

Int_t TGo4AnalysisMainRunnable::PostRun(void * )
{
   //cout << "test of main runnable postrun "<< endl;
   if (fxAnalysisClient && fxAnalysisClient->MainIsRunning()) fxAnalysis->PostLoop();
      // only execute postloop here is client was quit without stopping before
      // otherwise, TGo4AnalysisClient::Stop() has already called PostLoop
   return 0;
}

Int_t TGo4AnalysisMainRunnable::PreRun(void * )
{
   TRACE((12,"TGo4AnalysisMainRunnable::PreRun()",__LINE__, __FILE__));
   //cout << "test of main runnable prerun "<< endl;
   //fxAnalysis->PreLoop();
      // this thread will never be stopped during analysis lifetime!
      // preloop execution is obsolete here now, because AnalysisClient::Start will do that for us!
   return 0;
}

Int_t TGo4AnalysisMainRunnable::Run(void*)
{
   //TRACE((12,"TGo4AnalysisMainRunnable::Run()",__LINE__, __FILE__));
   //
try
   {
   if(fxAnalysisClient->IsCintMode() && fxAnalysisClient->MainIsRunning())
      {
         // when main loop is executing, do nothing to avoid
         // conflicts in ROOT  
         //cout <<"main runnable suspended: analysis is running" << endl;
         TGo4Thread::Sleep(fguPOLLINTERVAL); 
         return 0;
      }
  
   
   
   TGo4Command* com=fxAnalysisClient->NextCommand();
   //if(com== (TGo4Command*) -1) return 0; // for command memleak debug: no execute, no mainloop
   if(com)
     {
         if( com->GetCommandID() != TGo4Task::fgiTERMID )
            {
                // normal operation if we have not a terminate dummy command
               TGo4LockGuard mainlock; // protect command invocation!
               //cout <<"MMMMMMMM LLLLL Main runnable has lockguard on " <<TGo4LockGuard::fgxMainMutex<< endl;
                  TGo4CommandInvoker::Instance()->Invoke(com); // execute command by invoker
                  delete com;
            }
         else
            {
               // terminate dummy command: do not execute, but stop this thread
               //cout <<"Analysis main runnable got termid command" << endl;
               GetThread()->Stop();
            }
            
     }
   else  // if(com)
     {
        // zero object means proceed with analysis...
      // for analysis as server, we have to check running state again
      // (no command queue means no wait for next command)
      if(fxAnalysisClient->MainIsRunning() && !fxAnalysisClient->IsCintMode())
         {
            TGo4LockGuard mainguard; // global lock main actions
              fxAnalysis->MainCycle();
         }
      else
         {
            //cout <<"main runnable: analysis is not running" << endl;
            TGo4Thread::Sleep(fguPOLLINTERVAL);  
         }
      
      }  // if(com)
   return 0;
} // try

// begin catch block
catch(TGo4EventTimeoutException& ex)
{
   ex.Handle(); // display exception on terminal in case of debug
   if(TGo4Log::GetIgnoreLevel()<1)
      {
         // only display message if debug output enabled
         fxAnalysisClient->SendStatusMessage(2,kTRUE,"Analysis %s TIMEOUT for eventsource %s:%s.",
                  fxAnalysisClient->GetName(), ex.GetSourceClass(), ex.GetSourceName());
      } else{}
    return 0;
}
catch(TGo4EventEndException& ex)
{
fxAnalysisClient->SendStatusMessage(2,kTRUE,"End Of Eventsource %s:%s - %s",
                                 ex.GetSourceClass(),
                                 ex.GetSourceName(),ex.GetErrMess());
if(fxAnalysis->IsErrorStopEnabled()) fxAnalysisClient->Stop();
}
catch(TGo4EventErrorException& ex)
{
   //ex.Handle();
   Int_t prio=ex.GetPriority();
   if(prio==0)
      {
         // only display message without stop
         fxAnalysisClient->SendStatusMessage(1,kTRUE,"Eventsource %s:%s - %s",
                                 ex.GetSourceClass(),
                                 ex.GetSourceName(),ex.GetErrMess());
      }
   else
      {
      fxAnalysisClient->SendStatusMessage(3,kTRUE,"Analysis %s ERROR: %s from eventsource %s:%s",
                           fxAnalysisClient->GetName(),ex.GetErrMess(),
                           ex.GetSourceClass(), ex.GetSourceName());
      if(fxAnalysis->IsErrorStopEnabled()) fxAnalysisClient->Stop();
      }
   return 0;
}

catch(TGo4DynamicListException& ex)
{
   ex.Handle();
   fxAnalysisClient->SendStatusMessage(3,kTRUE,"Analysis %s ERROR: %s from dynamic list entry %s:%s",
                           fxAnalysisClient->GetName(),ex.GetStatusMessage(),
                           ex.GetEntryName(), ex.GetEntryClass());
   if(fxAnalysis->IsErrorStopEnabled())
      fxAnalysisClient->Stop();
   return 0;
}

catch(TGo4AnalysisStepException& ex)
{
   ex.Handle();
   fxAnalysisClient->SendStatusMessage(3,kTRUE,"Analysis %s ERROR: %s in Analysis Step %s",
                           fxAnalysisClient->GetName(), ex.GetStatusMessage(), ex.GetStepName());
   if(fxAnalysis->IsErrorStopEnabled())
         fxAnalysisClient->Stop();
   return 0;
}

catch(TGo4UserException& ex)
{
   //ex.Handle();
   fxAnalysisClient->SendStatusMessage(ex.GetPriority(),kTRUE,  ex.GetMessage() );
   if(fxAnalysis->IsErrorStopEnabled() && ex.GetPriority()>2)
         fxAnalysisClient->Stop(); // only stop for errors, warnings and infos continue loop!
   return 0;
}

catch(std::exception& ex) // treat standard library exceptions
{
   fxAnalysisClient->SendStatusMessage(3,kTRUE,"Analysis %s got standard exception %s",
                           fxAnalysisClient->GetName(), ex.what());
   if(fxAnalysis->IsErrorStopEnabled())
         fxAnalysisClient->Stop();
   return 0;
}
// end catch block
return 0;
}

//----------------------------END OF GO4 SOURCE FILE ---------------------

---